Files
stack/packages/bus/src/request-host.mjs
T
jason.woltje a8d9eecf65 organization: move packages/business to packages/organization (rename r2 stage B1)
git mv packages/business -> packages/organization (@mosaic/organization). The
old package stays as one-line re-export shims of each moved module, with
src/business.mjs re-exporting src/organization-config.mjs and src/cli.mjs
forwarding to the moved executable. BusinessError is OrganizationConfigError
(one constructor, name kept BusinessError); OrganizationError stays distinct.
The bus adapter gains organization-context.mjs (busOrganization), with
business.mjs (busBusiness) as the same function.

Import consumers, manifests, the lockfile, scripts/mosaic, stack-copy.sh
COPY_PATHS (both roots), seat sandbox RUNNER_FILES and the copy closure
walker (organization-imports.mjs, both roots required) move to the new path.
v1 serialization, v1 writers and the stage A fixtures are unchanged; the stage
A contract tests stay where they were and pass as before.
2026-11-09 11:47:48 -06:00

149 lines
9.8 KiB
JavaScript

// Lifecycle Task 2 (#797 / Gitea #1839, review I3): the host's own preparation and admission of a new-project
// plan, so a normal boot reaches a bootstrap selection without anything injected.
//
// Every input comes from something the host already holds: the validated organization document and its
// revision, the displayed source commit (prepareBootstrap reads it from the declared source checkout), the
// tracker configuration the host booted with, and the staff the organization names. A resource nothing can
// supply is a precise setup wait, never a placeholder: no tracker root, or a staff the organization does not
// name exactly, leaves the request waiting with a named code and creates nothing.
//
// Not verified here, because nothing the host holds can: that the tracker board the owner selected exists.
// That is checked when the first task is created, not before the owner confirms.
import { prepareBootstrap, prepareExistingPlan } from './request-bootstrap.mjs';
import { loadProject } from '../../organization/src/project.mjs';
import { digest, refuse } from './request-store.mjs';
const positive = n => Number.isSafeInteger(n) && n > 0;
const MODES = ['autonomous', 'guided'];
// The staff a bootstrapped project is built with, from the organization document alone: the request's PM, the
// technical arbiter, the launcher as chief, and the one launchable instance of each of the coder and reviewer
// roles. null unless every name is declared and the PM is not also the technical reviewer.
export function staffFor(document, pm) {
const roles = document?.roles, launch = document?.launch;
if (!roles || typeof roles !== 'object' || !launch || typeof launch.by !== 'string' || !Array.isArray(launch.instances)) return null;
const only = definition => {
const names = launch.instances.filter(i => roles[i]?.definition === definition);
return names.length === 1 ? names[0] : null;
};
const staff = { pm, technical_reviewer: document.arbiters?.technical, coder: only('coder'), reviewer: only('reviewer'), chief: launch.by };
const named = Object.values(staff).every(name => typeof name === 'string' && Object.hasOwn(roles, name));
return named && staff.pm !== staff.technical_reviewer ? staff : null;
}
// hostPreparation({ dataRoot, organization, trackers }) -> { preparePlans, admitPlan }
// `organization` is the organization writer, `trackers` the boot config's { business: { project, ... } }.
export function hostPreparation({ dataRoot, organization, trackers = null, journal, catalog, readSpec, admission, work = fn => fn() }) {
const read = business => { try { return organization.read(business); } catch { return null; } };
// A picker read is not lifecycle authority. Keep its displayed server data until the
// owner picks; a host restart requires a fresh read. The pick itself is journaled.
const displayed = new Map();
const owner = (state, now) => now?.document.human === state.owner;
const bindingFor = (business, project) => {
const origin = journal?.projectState(business, project);
const state = origin && journal.stateForRequest(origin.request);
return state?.selection?.bindings.find(b => b.digest === state.plan_digest)?.plan;
};
const inventory = state => {
const now = read(state.business);
if (!owner(state, now)) return [];
const found = resources(now.document, state.pm);
if (found.code) return [];
return Object.entries(now.document.projects).flatMap(([project, mapping]) => {
if (mapping.kind === 'library' || (admission && !admission({ business: state.business, project }).ready)) return [];
let config; try { config = loadProject(mapping.root); } catch { return []; }
if (config.id !== project) return [];
const previous = bindingFor(state.business, project);
const board = previous?.tracker.project ?? config.vars['tracker.project'];
if (!positive(board)) return [];
return [{ business: state.business, project, name: previous?.name ?? project,
tracker: { root: found.root, project: board }, mapping_revision: now.revision }];
});
};
// The tracker root board and the staff for one business, or the setup wait code that names what is missing.
const resources = (document, pm) => {
const root = trackers?.[document.id]?.project;
if (!positive(root)) return { code: 'request-tracker-unavailable' };
const staff = staffFor(document, pm);
return staff ? { root, staff } : { code: 'request-staff-unavailable' };
};
return {
listProjects(state, identity, { remember = true } = {}) {
const rows = inventory(state);
if (remember && identity?.human === state.owner) displayed.set(state.business + '/' + state.request, structuredClone(rows));
return rows;
},
pickExisting(state, project) {
const row = displayed.get(state.business + '/' + state.request)?.find(row => row.project === project);
if (!row) refuse('request-existing-project-changed');
const now = inventory(state).find(row => row.project === project);
if (!now || digest(now) !== digest(row)) refuse('request-existing-project-changed');
return row;
},
prepareExisting(state, args, from) {
const now = read(state.business);
if (!owner(state, now)) return { ready: false, code: 'request-organization-unavailable' };
if (state.attachment?.mapping_revision !== now.revision) return { ready: false, code: 'request-existing-project-changed' };
const row = inventory(state).find(row => row.project === args.project);
if (!row) return { ready: false, code: 'request-project-refused' };
const mode = journal.projectState(state.business, args.project)?.mode ?? 'guided';
return prepareExistingPlan({ business: now.document, request: state.request, project: args.project, name: row.name, mode,
dataRoot, organizationRevision: now.revision, tracker: row.tracker, staff: resources(now.document, state.pm).staff,
intent: { text: from.text, source_message: from.source_message } });
},
withExisting(state, fn) { return work(() => organization.holdAsync(state.business, fn)); },
async attachExisting(state, plan) {
const checked = this.admitPlan(plan);
if (!checked.ready) refuse(checked.code);
const mode = journal.projectState(state.business, state.project);
const spec = await readSpec({ business: state.business, project: state.project });
if (!spec.confirmed) refuse('stale-spec');
let snapshot = null, candidate = null;
try {
const current = await catalog.resolve({ business: state.business, project: state.project });
const source = current.origin === 'product' && journal.snapshotRequest(current.id);
// Exact prior intent is a provable fit. New intent needs PM discovery/revision,
// never guessed semantic equivalence or authority from a bare requirement id.
if (source && journal.intent(state.business, source)?.text === plan.intent.text) {
const original = journal.stateForRequest(source);
const submitted = journal.submission(state.business, source, current.approval.decision);
if (original?.project === state.project && submitted) { snapshot = current.id; candidate = submitted.candidate; }
}
} catch (e) {
if (!['requirement-snapshot-required','requirement-snapshot-revoked','prd-candidate-stale'].includes(e.code)) throw e;
}
const late = this.admitPlan(plan); if (!late.ready) refuse(late.code);
return { spec_commit: spec.commit, mode_revision: mode?.revision ?? 1, snapshot, candidate };
},
async preparePlans(state, args, from) {
const now = read(state.business);
if (!now) return { ready: false, code: 'request-organization-unavailable' };
const found = resources(now.document, state.pm);
if (found.code) return { ready: false, code: found.code };
return Promise.all(MODES.map(mode => prepareBootstrap({ business: now.document, request: state.request, sourceProject: args.source_project,
project: args.project, name: args.name, mode, dataRoot, organizationRevision: now.revision, tracker: { root: found.root, project: args.tracker_project },
staff: found.staff, intent: { text: from.text, source_message: from.source_message } })));
},
// May this plan be shown and confirmed: the organization is still at the revision it was prepared on, and the
// resources it names are the ones the host holds now.
admitPlan(plan) {
const now = read(plan.business);
if (!now) return { ready: false, code: 'request-organization-unavailable' };
if (now.revision !== plan.organization_revision) return { ready: false, code: 'request-organization-changed' };
const found = resources(now.document, plan.staff.pm);
if (found.code) return { ready: false, code: found.code };
if (plan.tracker.root !== found.root) return { ready: false, code: 'request-tracker-unavailable' };
if (Object.keys(found.staff).some(k => plan.staff[k] !== found.staff[k])) return { ready: false, code: 'request-staff-unavailable' };
if (plan.existing) {
const row = inventory({ business: plan.business, owner: now.document.human, pm: plan.staff.pm }).find(row => row.project === plan.project);
if (!row || digest(row.tracker) !== digest(plan.tracker)) return { ready: false, code: 'request-existing-project-changed' };
const mode = journal.projectState(plan.business, plan.project)?.mode ?? 'guided';
const current = prepareExistingPlan({ business: now.document, request: plan.request, project: plan.project, name: row.name, mode,
dataRoot, organizationRevision: now.revision, tracker: row.tracker, staff: found.staff, intent: plan.intent, chat_project: plan.chat_project });
if (digest(current) !== digest(plan)) return { ready: false, code: 'request-existing-project-changed' };
}
return { ready: true };
},
};
}