pi-daddy 0.27.4 → 0.32.0

package/src/work-policy-registry.ts

@@ -1,81 +0,0 @@
-import { createControlJournal, controlJournal, type ControlBinding } from "./control-journal.ts";
-import { experimentHash, closed, cloneExperiment } from "./experiment-contract.ts";
-import { buildAdoptionBinding, buildRollbackRequest, validateAdoptionReceipt, authorizeRollback, type AdoptionBinding, type AdoptionReceipt, type RollbackRequest } from "./vendor/adoption.ts";
-import { factoryAuthority, requireFactoryAuthority, type FactoryAuthority } from "./factory-contract.ts";
-import { WORK_EFFORTS, type WorkSetup } from "./work-setup.ts";
-
-/** Additive profile: ONLY model/effort may change. Task IDs and definition names stay fixed. Normal definition-digest/grant checks still run; this is not a filesystem pin. */
-export interface WorkPolicy { version: "ordinary-work-policy-v1"; scopeDigest: string; assessmentPolicyDigest: string; profiles: { taskId: string; agent: string | null; model: string; thinking: typeof WORK_EFFORTS[number] }[] }
-export interface WorkPolicyInitial { version: "ordinary-work-registry-v1"; authorityId: string; scopeDigest: string; baseline: WorkPolicy }
-export type WorkPolicyRegistry = ControlBinding<WorkPolicyInitial>;
-export interface WorkPolicyActivation { version: "ordinary-work-activation-v1"; requestId: string; expectedRevision: number; expectedCandidateDigest: string; candidate: WorkPolicy; binding: AdoptionBinding; receipt: AdoptionReceipt }
-const sha = (x: unknown) => typeof x === "string" && /^[a-f0-9]{64}$/.test(x);
-export function workPolicy(input: WorkPolicy): WorkPolicy {
-  const p = cloneExperiment(input); closed(p, ["version", "scopeDigest", "assessmentPolicyDigest", "profiles"]);
-  if (p.version !== "ordinary-work-policy-v1" || !sha(p.scopeDigest) || !sha(p.assessmentPolicyDigest) || !Array.isArray(p.profiles) || !p.profiles.length || p.profiles.length > 8) throw Error("unsupported ordinary policy profile");
-  for (const t of p.profiles) { closed(t, ["taskId", "agent", "model", "thinking"]); if (!/^[A-Za-z0-9][A-Za-z0-9_-]{0,31}$/.test(t.taskId) || !(t.agent === null || typeof t.agent === "string" && /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(t.agent)) || !/^[A-Za-z0-9._-]+\/[A-Za-z0-9._:/@+-]+$/.test(t.model) || t.model.length > 128 || !WORK_EFFORTS.includes(t.thinking)) throw Error("invalid model/effort profile; no fallback"); }
-  if (new Set(p.profiles.map(t => t.taskId)).size !== p.profiles.length) throw Error("duplicate profile task");
-  return p;
-}
-export const workPolicyDigest = (p: WorkPolicy) => experimentHash(workPolicy(p));
-export const workPolicyActivationDigest = (r: WorkPolicyActivation) => experimentHash(r);
-export function policyForSetup(setup: WorkSetup, scopeDigest: string, assessmentPolicyDigest: string): WorkPolicy { return workPolicy({ version: "ordinary-work-policy-v1", scopeDigest, assessmentPolicyDigest, profiles: setup.tasks.map(({ id: taskId, agent, model, thinking }) => ({ taskId, agent, model, thinking })) }); }
-function compatible(baseline: WorkPolicy, candidate: WorkPolicy) {
-  const shape = (p: WorkPolicy) => p.profiles.map(t => ({ taskId: t.taskId, agent: t.agent })).sort((a, b) => a.taskId.localeCompare(b.taskId));
-  if (baseline.scopeDigest !== candidate.scopeDigest || baseline.assessmentPolicyDigest !== candidate.assessmentPolicyDigest || experimentHash(shape(baseline)) !== experimentHash(shape(candidate))) throw Error("policy changes may only select models/effort for the same scoped definitions; no instruction, capability, topology or assessment expansion");
-}
-function replay(binding: WorkPolicyRegistry, events: Record<string, unknown>[]) {
-  const initial = binding.initial; closed(initial, ["version", "authorityId", "scopeDigest", "baseline"]);
-  if (initial.version !== "ordinary-work-registry-v1" || !/^[a-zA-Z0-9:_-]{1,128}$/.test(initial.authorityId) || initial.scopeDigest !== workPolicy(initial.baseline).scopeDigest) throw Error("invalid policy registry binding");
-  let candidate = initial.baseline, revision = 0, active: WorkPolicyActivation | null = null;
-  let lastChange: {operation:"activate"|"rollback";requestId:string;adoptionId:string}|null=null;
-  const lineage: (WorkPolicyActivation | null)[] = [], policies = new Map([[workPolicyDigest(candidate), candidate]]), requests = new Map<string, string>(), orders = new Map<string, { candidateDigest: string; adoptionId: string | null; revision: number }>();
-  for (const e of events) {
-    if (e.type === "activate") {
-      closed(e, ["type", "request"]); const r = e.request as unknown as WorkPolicyActivation; closed(r, ["version", "requestId", "expectedRevision", "expectedCandidateDigest", "candidate", "binding", "receipt"]);
-      const { version, id, ...draft } = r.binding;
-      if (r.version !== "ordinary-work-activation-v1" || !/^[a-zA-Z0-9:_-]{1,128}$/.test(r.requestId) || requests.has(r.requestId) || r.expectedRevision !== revision || r.expectedCandidateDigest !== workPolicyDigest(candidate) || version !== "adoption-binding-v1" || buildAdoptionBinding(draft).id !== id || r.binding.scopeDigest !== initial.scopeDigest || r.binding.candidateDigest !== workPolicyDigest(r.candidate) || r.binding.rollbackCandidateDigest !== workPolicyDigest(candidate) || r.binding.assessmentPolicyDigest !== r.candidate.assessmentPolicyDigest || r.receipt.bindingId !== id || r.receipt.authorityId !== initial.authorityId) throw Error("invalid activation sequence");
-      validateAdoptionReceipt(r.receipt, r.binding, { id: r.receipt.authorityId, adoptions: [r.binding.id], rollbacks: [] }, { experimentDigest: r.binding.experimentDigest, candidateDigest: r.binding.candidateDigest, scopeDigest: r.binding.scopeDigest, assessmentPolicyDigest: r.binding.assessmentPolicyDigest, eligible: true }, 0); // Structural replay only; activate/pin independently authorize again at use.
-      compatible(initial.baseline, workPolicy(r.candidate)); requests.set(r.requestId, workPolicyActivationDigest(r)); lineage.push(active); active = r; candidate = r.candidate; policies.set(workPolicyDigest(candidate), candidate); revision++; lastChange={operation:"activate",requestId:r.requestId,adoptionId:r.receipt.id};
-    } else if (e.type === "rollback") {
-      closed(e, ["type", "request", "fromRevision"]); const r = e.request as unknown as RollbackRequest;
-      if (!active || experimentHash(buildRollbackRequest(active.receipt,r.reason,[...r.evidence],r.expiresAt)) !== experimentHash(r) || e.fromRevision !== revision || requests.has(r.id) || r.adoptionId !== active.receipt.id || r.scopeDigest !== initial.scopeDigest || r.restoreCandidateDigest !== active.binding.rollbackCandidateDigest || !policies.has(r.restoreCandidateDigest)) throw Error("invalid rollback sequence");
-      candidate = policies.get(r.restoreCandidateDigest)!; if(!lineage.length)throw Error("missing rollback lineage"); active = lineage.pop() ?? null; if((active?.binding.candidateDigest??workPolicyDigest(initial.baseline))!==workPolicyDigest(candidate))throw Error("rollback lineage mismatch"); requests.set(r.id, experimentHash(r)); revision++; lastChange={operation:"rollback",requestId:r.id,adoptionId:r.adoptionId};
-    } else if (e.type === "order-pin") {
-      closed(e, ["type", "orderId", "candidateDigest", "adoptionId", "revision"]);
-      if (typeof e.orderId !== "string" || !/^[a-zA-Z0-9:_-]{1,128}$/.test(e.orderId) || orders.has(e.orderId) || e.candidateDigest !== workPolicyDigest(candidate) || e.adoptionId !== (active?.receipt.id ?? null) || e.revision !== revision) throw Error("invalid future-order pin");
-      orders.set(e.orderId, { candidateDigest: String(e.candidateDigest), adoptionId: e.adoptionId as string | null, revision });
-    } else throw Error("unknown work policy registry event");
-  }
-  return { candidate, revision, active, requests, orders, lastChange };
-}
-export async function createWorkPolicyRegistry(input: { directory: string; authorityId: string; baseline: WorkPolicy }): Promise<WorkPolicyRegistry> {
-  const baseline = workPolicy(input.baseline);
-  return createControlJournal(input.directory, { version: "ordinary-work-registry-v1", authorityId: input.authorityId, scopeDigest: baseline.scopeDigest, baseline });
-}
-export function openWorkPolicyRegistry(binding: WorkPolicyRegistry) {
-  const store = controlJournal(binding);
-  const inspect = async () => { const s = replay(binding, (await store.read()).events); return { version: "factory-registry-view-v1" as const, profile: "ordinary-model-effort-v1", scopeDigest: binding.initial.scopeDigest, candidateDigest: workPolicyDigest(s.candidate), candidate: s.candidate, revision: s.revision, activation: s.active, lastChange:s.lastChange, application:s.lastChange?"applied":"not-performed", requestId:s.lastChange?.requestId??null, orders: [...s.orders].map(([orderId, pin]) => ({ orderId, ...pin })), acceptance: "not-assessed" }; };
-  const authority = (host: FactoryAuthority | null) => requireFactoryAuthority(factoryAuthority(host), binding.initial.authorityId);
-  const eligible = (r: WorkPolicyActivation, host: FactoryAuthority) => { const facts = host.facts.find(f => f.bindingId === r.binding.id)?.facts; if (!facts) throw Error("current independent eligibility facts required"); validateAdoptionReceipt(r.receipt, r.binding, host.adoption, facts, Date.now()); };
-  return { inspect,
-    /** Pure validated replay of the proposed rollback; resolves original retained bytes, never a mutable named file. */
-    async previewRollback(request: RollbackRequest) {
-      const r=cloneExperiment(request),events=(await store.read()).events,s=replay(binding,events);
-      const restored=replay(binding,[...events,{type:"rollback",request:r,fromRevision:s.revision}]);
-      return {requestId:r.id,adoptionId:r.adoptionId,expectedRevision:s.revision,restoreCandidateDigest:workPolicyDigest(restored.candidate),candidate:cloneExperiment(restored.candidate)};
-    },
-    async activate(request: WorkPolicyActivation, host: FactoryAuthority | null) {
-      const r = cloneExperiment(request), a = authority(host); if (!a.activationDigests.includes(workPolicyActivationDigest(r))) throw Error("exact independent activation approval required");
-      await store.transaction(async (events, append) => { eligible(r,a); const s = replay(binding, events), old = s.requests.get(r.requestId); if (old) { if (old !== workPolicyActivationDigest(r)) throw Error("immutable activation ID"); return; } const event = { type: "activate", request: r }; replay(binding, [...events, event]); await append(event); }); return inspect();
-    },
-    async rollback(request: RollbackRequest, host: FactoryAuthority | null) {
-      const r = cloneExperiment(request), a = authority(host);
-      await store.transaction(async (events, append) => { const s = replay(binding, events), old = s.requests.get(r.id); if (old) { if (old !== experimentHash(r) || !a.adoption?.rollbacks.includes(r.id)) throw Error("rollback identity/authority mismatch"); return; } if (!s.active) throw Error("no active adoption to roll back"); authorizeRollback(s.active.receipt, r, a.adoption, Date.now(), { adoptionId: s.active.receipt.id, candidateDigest: workPolicyDigest(s.candidate), scopeDigest: binding.initial.scopeDigest }); const event = { type: "rollback", request: r, fromRevision: s.revision }; replay(binding, [...events, event]); await append(event); }); return { ...await inspect(), application: "applied" as const, requestId: r.id, grantExpansion: false };
-    },
-    async pin(orderId: string, host: FactoryAuthority | null, expected: { revision: number; candidateDigest: string }) {
-      const a = authority(host);
-      return store.transaction(async (events, append) => { const s = replay(binding, events); if(s.revision!==expected.revision||workPolicyDigest(s.candidate)!==expected.candidateDigest)throw Error("registry changed before order pin"); if (s.orders.has(orderId)) throw Error("order already pinned; never relaunch on readback"); if (s.active) eligible(s.active, a); const event = { type: "order-pin", orderId, candidateDigest: workPolicyDigest(s.candidate), adoptionId: s.active?.receipt.id ?? null, revision: s.revision }; replay(binding, [...events, event]); await append(event); return { ...event, candidate: s.candidate }; });
-    },
-  };
-}

package/src/work-run.ts

@@ -1,79 +0,0 @@
-import { randomUUID, createHash } from "node:crypto";
-import { writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { setTimeout as wait } from "node:timers/promises";
-import { createControlJournal, controlJournal, type ControlBinding } from "./control-journal.ts";
-import { composeStepTask, HANDOFF_MAX_BYTES } from "./chain.ts";
-import { splitBudget } from "./fanout.ts";
-import { workSetup, type WorkSetup, type WorkTaskSetup } from "./work-setup.ts";
-
-export interface WorkRunOutcome { ok: boolean; text: string; reason?: string; control?: "failed"; exitCode: number | null; truncated?: boolean; aborted?: boolean; timedOut?: boolean }
-export interface WorkRunTask { id: string; state: "waiting" | "running" | "finished" | "failed" | "blocked"; executionId: string | null; resultPath: string | null; resultDigest: string | null; reason: string | null }
-export interface WorkPolicyPin { orderId: string; candidateDigest: string; adoptionId: string | null; revision: number; scopeDigest: string }
-export interface WorkRunInitial { version: "work-run-v1"; runId: string; selectionDigest: string; setup: WorkSetup; policyPin: WorkPolicyPin | null }
-export interface WorkRunResult { binding: ControlBinding<WorkRunInitial>; tasks: WorkRunTask[]; acceptance: "not-assessed" }
-/** Finite DAG scheduler only. Execution, grants, cancellation, deadlines and observation remain original-owner operations. */
-export async function runWorkSetup(input: {
-  directory: string; selectionDigest: string; setup: WorkSetup; budget: number; signal?: AbortSignal; orderId?: string; policyPin?: WorkPolicyPin | null;
-  execute(task: WorkTaskSetup, prompt: string, perChildBudget: number, started: (executionId: string) => Promise<void>): Promise<WorkRunOutcome>;
-  onUpdate?: (tasks: readonly WorkRunTask[]) => void;
-  priorities?: string[];
-  /** Read the existing owner hold; waiting here never grants or performs a control action. */
-  admissionOpen?: () => boolean;
-}): Promise<WorkRunResult> {
-  const setup = workSetup(input.setup), split = splitBudget(input.budget, setup.tasks.length);
-  if (!split.ok) throw Error(split.reason);
-  if (!/^[a-f0-9]{64}$/.test(input.selectionDigest)) throw Error("exact selected work digest required");
-  const order = input.priorities ?? setup.tasks.map(t => t.id);
-  if (order.length !== setup.tasks.length || new Set(order).size !== order.length || order.some(id => !setup.tasks.some(t => t.id === id))) throw Error("priority must name each task exactly once");
-  const binding = await createControlJournal(input.directory, { version: "work-run-v1" as const, runId: input.orderId ?? randomUUID(), selectionDigest: input.selectionDigest, setup, policyPin: input.policyPin ?? null });
-  const journal = controlJournal(binding), outcomes = new Map<string, WorkRunOutcome>();
-  const tasks: WorkRunTask[] = order.map(id => ({ id, state: "waiting", executionId: null, resultPath: null, resultDigest: null, reason: null }));
-  const running = new Map<string, Promise<void>>();
-  let persistenceFailure: unknown;
-  const publish = () => { try { input.onUpdate?.(tasks.map(t => ({ ...t }))); } catch { /* display is not execution */ } };
-  const record = (task: WorkRunTask) => journal.transaction(async (_events, append) => append({ type: "task", ...task }));
-  while (tasks.some(t => t.state === "waiting") || running.size) {
-    for (const row of tasks.filter(t => t.state === "waiting")) {
-      const spec = setup.tasks.find(t => t.id === row.id)!;
-      if (input.signal?.aborted || persistenceFailure || spec.dependencies.some(d => ["failed", "blocked"].includes(tasks.find(t => t.id === d)!.state))) {
-        row.state = "blocked"; row.reason = input.signal?.aborted ? "Cancelled before admission" : persistenceFailure ? "Result/control persistence failed; no further admission" : "A dependency did not finish successfully";
-        try { await record(row); } catch (error) { persistenceFailure ??= error; }
-        continue;
-      }
-      if (input.admissionOpen?.() === false || running.size >= setup.maxParallel || !spec.dependencies.every(d => tasks.find(t => t.id === d)!.state === "finished")) continue;
-      row.state = "running";
-      const pending = (async () => {
-        try {
-          const previous = spec.dependencies.map(d => `${d}\n${outcomes.get(d)!.text}`).join("\n\n");
-          if (Buffer.byteLength(previous) > HANDOFF_MAX_BYTES) throw Error("Complete predecessor output exceeds the 32 KiB handoff bound; dependent work was not launched");
-          await record(row);
-          const outcome = await input.execute(spec, composeStepTask(spec.outcome, spec.dependencies.length ? previous : undefined), split.perChild, async executionId => { row.executionId = executionId; await record(row); publish(); });
-          outcomes.set(spec.id, outcome);
-          if (Buffer.byteLength(outcome.text) > 1024 * 1024) throw Error("original child result exceeds retention bound");
-          const bytes = Buffer.from(outcome.text), file = `${spec.id}.txt`;
-          await writeFile(join(binding.directory, file), bytes, { mode: 0o600, flag: "wx" });
-          row.resultPath = join(binding.directory, file); row.resultDigest = createHash("sha256").update(bytes).digest("hex");
-          row.state = outcome.ok && !outcome.control && !outcome.truncated ? "finished" : "failed";
-          row.reason = row.state === "finished" ? null : outcome.reason ?? (outcome.control ? "Observation/control failed" : outcome.truncated ? "Output truncated" : "Attempt failed");
-        } catch (error) { row.state = "failed"; row.reason = String(error); }
-        try { await record(row); } catch (error) { persistenceFailure ??= error; row.state = "failed"; row.reason = `Control acknowledgement unknown: ${String(error)}`; }
-        publish();
-      })().finally(() => running.delete(row.id));
-      running.set(row.id, pending); publish();
-    }
-    publish();
-    if (running.size) await Promise.race(running.values());
-    else if(tasks.some(t=>t.state==="waiting"))await wait(100,undefined,{signal:input.signal}).catch(error=>{if(!input.signal?.aborted)throw error;});
-  }
-  // No detached promises, restart relaunch, refund or retry. Original children have all settled here.
-  if (persistenceFailure) throw Error(`Work results may exist but control persistence failed: ${String(persistenceFailure)}`);
-  return { binding, tasks, acceptance: "not-assessed" };
-}
-export async function inspectWorkRun(binding: ControlBinding<WorkRunInitial>): Promise<WorkRunResult> {
-  workSetup(binding.initial.setup);
-  if (binding.initial.version !== "work-run-v1") throw Error("unsupported work run");
-  const rows = new Map<string, WorkRunTask>();
-  for (const event of (await controlJournal(binding).read()).events) if (event.type === "task") rows.set(String(event.id), event as unknown as WorkRunTask);
-  return { binding, tasks: binding.initial.setup.tasks.map(t => rows.get(t.id) ?? { id: t.id, state: "waiting", executionId: null, resultPath: null, resultDigest: null, reason: "No launch acknowledgement; do not infer or retry" }), acceptance: "not-assessed" };
-}

package/src/work-setup.ts

@@ -1,141 +0,0 @@
-import { createHash } from "node:crypto";
-import { readFile, readdir } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
-import { appendWorkLedgerEventOnce, buildWorkRevisionEvent, buildWorkSnapshotEvent, type RevisionRef, type WorkRevision, type WorkRevisionEvent, type WorkSnapshotEvent, type WorkFrozen } from "./work-ledger.ts";
-import { resolveWorkSnapshotText } from "./work-ledger-snapshot.ts";
-import { loadDeclaredWork, type DeclaredWorkState } from "./work-command.ts";
-import { withFileLock } from "./file-lock.ts";
-import { intentKey, type IntentSelection } from "./intent-control.ts";
-import { privateDirectory, projectProductDirectory, readProductJson, writeProductJson } from "./product-files.ts";
-import type { WorkPresentation } from "./daily-panel.ts";
-
-export const WORK_EFFORTS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
-export interface WorkTaskSetup { id: string; outcome: string; agent: string | null; model: string; thinking: typeof WORK_EFFORTS[number]; dependencies: string[] }
-export interface WorkSetup { version: "work-setup-v1"; id: string; outcome: string; maxParallel: number; tasks: WorkTaskSetup[] }
-export interface RecordedWorkSetup { version: "recorded-work-setup-v1"; setup: WorkSetup; state: DeclaredWorkState; tasks: { id: string; obligation: RevisionRef }[]; events: WorkFrozen<WorkRevisionEvent | WorkSnapshotEvent>[] }
-const hash = (value: string) => createHash("sha256").update(value).digest("hex");
-const keys = (value: object, expected: string[]) => { if (!value || typeof value !== "object" || Object.keys(value).sort().join() !== expected.sort().join()) throw Error("unsupported work setup fields"); };
-const id = (value: unknown) => typeof value === "string" && /^[A-Za-z0-9][A-Za-z0-9_-]{0,31}$/.test(value);
-const text = (value: unknown) => typeof value === "string" && value.trim().length > 0 && Buffer.byteLength(value) <= 8192;
-const ref = (r: Pick<WorkRevision, "kind" | "id" | "revision" | "digest">): RevisionRef => ({ kind: r.kind, id: r.id, revision: r.revision, digest: r.digest });
-export function workSetup(input: WorkSetup): WorkSetup {
-  const s = JSON.parse(JSON.stringify(input)) as WorkSetup;
-  keys(s, ["version", "id", "outcome", "maxParallel", "tasks"]);
-  if (s.version !== "work-setup-v1" || !id(s.id) || !text(s.outcome) || !Number.isInteger(s.maxParallel) || s.maxParallel < 1 || s.maxParallel > 8 || !Array.isArray(s.tasks) || !s.tasks.length || s.tasks.length > 8) throw Error("work setup requires 1–8 tasks and parallel limit 1–8");
-  const seen = new Set<string>();
-  for (const task of s.tasks) {
-    keys(task, ["id", "outcome", "agent", "model", "thinking", "dependencies"]);
-    if (!id(task.id) || seen.has(task.id) || !text(task.outcome) || !(task.agent === null || typeof task.agent === "string" && /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(task.agent)) || typeof task.model !== "string" || !/^[A-Za-z0-9._-]+\/[A-Za-z0-9._:/@+-]+$/.test(task.model) || task.model.length > 128 || !WORK_EFFORTS.includes(task.thinking) || !Array.isArray(task.dependencies) || new Set(task.dependencies).size !== task.dependencies.length || task.dependencies.some(d => !id(d) || d === task.id)) throw Error("invalid task, model/effort or dependency; no profile fallback");
-    seen.add(task.id);
-  }
-  const done = new Set<string>();
-  while (done.size < s.tasks.length) {
-    const eligible = s.tasks.filter(t => !done.has(t.id) && t.dependencies.every(d => done.has(d)));
-    if (!eligible.length) throw Error("dependencies contain a cycle or missing task");
-    eligible.forEach(t => done.add(t.id));
-  }
-  return s;
-}
-const setupPath = (state: DeclaredWorkState) => join(dirname(state.statePath), "work-setups", `${state.selectedSnapshot.snapshot.digest}.json`);
-
-/** Author first, append through P01, then select separately at an explicit owner boundary. */
-export async function recordWorkSetup(cwd: string, value: WorkSetup, mode: "new" | "revise" | "alternative" = "new", expected: DeclaredWorkState | null = null): Promise<RecordedWorkSetup> {
-  const setup = workSetup(value), root = join(resolve(cwd), ".pi"), statePath = join(root, "work-current.json");
-  await projectProductDirectory(root); await privateDirectory(join(root, "work-setups"));
-  return withFileLock(statePath, "work setup", async () => {
-    const current = await loadDeclaredWork(statePath);
-    if (intentKey(current?.selectedSnapshot ?? null) !== intentKey(expected?.selectedSnapshot ?? null)) throw Error("work selection changed; reopen setup");
-    if (mode !== "new" && !current) throw Error("select existing work before recording a revision");
-    const original = mode !== "new" ? await loadWorkSetup(current!) : null;
-    if (mode !== "new" && (!original || original.setup.tasks.length !== setup.tasks.length || original.setup.tasks.some(t => !setup.tasks.some(n => n.id === t.id && intentKey([...n.dependencies].sort()) === intentKey([...t.dependencies].sort()))))) throw Error("topology changes require a new work setup; no live entity expansion");
-    const revisions = current && mode !== "new" ? resolveWorkSnapshotText(await readFile(current.ledgerPath, "utf8"), current.selectedSnapshot) : null;
-    const token = hash(intentKey({ setup, mode, from: mode === "new" ? null : current?.selectedSnapshot })).slice(0, 24), prefix = mode === "new" ? `work:${setup.id}:${token.slice(0, 8)}` : current!.scope.id.replace(/:scope$/, "");
-    // Preparation is durable before the first append, so an interrupted exact retry retains timestamps/identities.
-    const preparedPath = join(root, "work-setups", `pending-${token}.json`);
-    const prepared = await readProductJson(preparedPath) as { now: string } | null;
-    if (prepared && (Object.keys(prepared).join() !== "now" || !Number.isFinite(Date.parse(prepared.now)))) throw Error("invalid retained setup preparation");
-    const now = new Date(prepared?.now ?? Date.now());
-    if (!prepared) await writeProductJson(preparedPath, { now: now.toISOString() });
-    const events: WorkFrozen<WorkRevisionEvent | WorkSnapshotEvent>[] = [];
-    const build = (kind: WorkRevision["kind"], entityId: string, content: unknown, parent: RevisionRef | null, dependencies: RevisionRef[] = [], policy: RevisionRef | null = null): RevisionRef => {
-      const prior = revisions && [revisions.scope!, ...revisions.revisions].find(r => r.kind === kind && r.id === entityId);
-      const event = buildWorkRevisionEvent({ eventId: `${prefix}:${token}:${kind}:${events.length}`, now, revision: { kind, id: entityId, revision: prior ? prior.revision + 1 : 1, predecessor: prior ? ref(prior) : null, scopeId: `${prefix}:scope`, contentDigest: hash(intentKey(content)), parent, dependencies, ownerId: prior?.ownerId ?? "local-operator", permittedEffects: prior ? [...prior.permittedEffects] : [], policy } });
-      events.push(event); return ref(event.payload.revision);
-    };
-    const scope = mode === "alternative" ? current!.scope : build("scope", `${prefix}:scope`, setup, null);
-    const policy = mode === "new" ? build("policy", `${prefix}:policy`, { acceptance: "independent-review-required" }, null) : current!.policy;
-    const intent = build("goal", mode === "new" ? `${prefix}:goal` : current!.intent.id, setup, scope);
-    const tasks: RecordedWorkSetup["tasks"] = [];
-    while (tasks.length < setup.tasks.length) {
-      for (const task of setup.tasks) {
-        if (tasks.some(t => t.id === task.id) || !task.dependencies.every(d => tasks.some(t => t.id === d))) continue;
-        const entityId = original?.tasks.find(t => t.id === task.id)?.obligation.id ?? `${prefix}:${task.id}`;
-        const obligation = build("obligation", entityId, task, intent, task.dependencies.map(d => tasks.find(t => t.id === d)!.obligation), policy);
-        tasks.push({ id: task.id, obligation });
-      }
-    }
-    const ordered = setup.tasks.map(t => tasks.find(x => x.id === t.id)!);
-    const snapshot = buildWorkSnapshotEvent({ eventId: `${prefix}:${token}:snapshot`, now, snapshot: { snapshotId: `${prefix}:${token}:selected`, scope, revisions: [policy, intent, ...ordered.map(t => t.obligation)], bindings: ordered.map(t => ({ intent, obligation: t.obligation, artifact: null, policy })) } });
-    events.push(snapshot);
-    const state: DeclaredWorkState = { version: "pi-daddy-declared-work-v1", id: setup.id, outcomeDigest: hash(setup.outcome.trim()), ledgerPath: join(root, "work.jsonl"), statePath, grantLedgerPath: null, selectedSnapshot: { snapshot: { id: snapshot.payload.snapshot.snapshotId, digest: snapshot.payload.snapshot.digest }, event: { eventId: snapshot.eventId, digest: snapshot.digest } }, scope, intent, obligation: ordered[0].obligation, policy };
-    const result: RecordedWorkSetup = { version: "recorded-work-setup-v1", setup, state, tasks: ordered, events };
-    const path = setupPath(state), previous = await readProductJson(path);
-    if (previous && intentKey(previous) !== intentKey(result)) throw Error("recorded setup identity conflict");
-    if (!previous) await writeProductJson(path, result);
-    for (const event of events) await appendWorkLedgerEventOnce({ path: state.ledgerPath, grantLedgerPath: null }, event);
-    await loadWorkSetup(state); return result;
-  });
-}
-
-export async function loadWorkSetup(state: DeclaredWorkState): Promise<RecordedWorkSetup | null> {
-  const value = await readProductJson(setupPath(state)) as RecordedWorkSetup | null;
-  if (!value) return null;
-  keys(value, ["version", "setup", "state", "tasks", "events"]);
-  const setup = workSetup(value.setup);
-  if (value.version !== "recorded-work-setup-v1" || intentKey(value.state.selectedSnapshot) !== intentKey(state.selectedSnapshot) || value.state.ledgerPath !== state.ledgerPath || value.state.statePath !== state.statePath || hash(setup.outcome.trim()) !== value.state.outcomeDigest || !Array.isArray(value.tasks) || value.tasks.length !== setup.tasks.length) throw Error("work setup selection mismatch");
-  const resolved = resolveWorkSnapshotText(await readFile(state.ledgerPath, "utf8"), state.selectedSnapshot);
-  if (resolved.scopeState !== "valid" || !resolved.snapshot || hash(intentKey(setup)) !== resolved.revisions.find(r => r.digest === value.state.intent.digest)?.contentDigest) throw Error("recorded work labels are stale or mismatched");
-  if (intentKey(resolved.snapshot.scope) !== intentKey(value.state.scope) || !resolved.snapshot.bindings.some(b => intentKey(b.intent) === intentKey(value.state.intent) && intentKey(b.policy) === intentKey(value.state.policy) && intentKey(b.obligation) === intentKey(state.obligation))) throw Error("work state is not an exact selected binding");
-  for (const task of setup.tasks) {
-    const binding = value.tasks.find(t => t.id === task.id), revision = resolved.revisions.find(r => r.digest === binding?.obligation.digest);
-    if (!binding || !revision || revision.contentDigest !== hash(intentKey(task)) || !resolved.snapshot.bindings.some(b => intentKey(b.obligation) === intentKey(binding.obligation))) throw Error("task configuration is not bound to selected work");
-  }
-  return value;
-}
-/** Caller must own a quiescent session, with no running daily host. No active order is rebound. */
-export async function selectRecordedWork(recorded: RecordedWorkSetup, expected: IntentSelection | null): Promise<DeclaredWorkState> {
-  const state = recorded.state;
-  return withFileLock(state.statePath, "select work", async () => {
-    const current = await loadDeclaredWork(state.statePath);
-    if (intentKey(current?.selectedSnapshot ?? null) !== intentKey(expected)) throw Error("selection changed; no work selected");
-    if (!await loadWorkSetup(state)) throw Error("recorded setup missing");
-    const { statePath: _path, ...stored } = state;
-    await writeProductJson(state.statePath, stored, true); return state;
-  });
-}
-export async function listWorkSetups(cwd: string): Promise<RecordedWorkSetup[]> {
-  const root = join(resolve(cwd), ".pi", "work-setups");
-  let files: string[]; try { files = await readdir(root); } catch (error) { if ((error as NodeJS.ErrnoException).code === "ENOENT") return []; throw error; }
-  if (files.length > 256) throw Error("work setup history bound exceeded");
-  const results: RecordedWorkSetup[] = [];
-  for (const file of files.filter(f => /^[a-f0-9]{64}\.json$/.test(f)).sort()) {
-    const value = await readProductJson(join(root, file)) as RecordedWorkSetup;
-    if (value?.state?.statePath !== join(resolve(cwd), ".pi", "work-current.json") || file !== `${value.state.selectedSnapshot.snapshot.digest}.json`) throw Error("invalid work setup history");
-    results.push((await loadWorkSetup(value.state))!);
-  }
-  return results;
-}
-export async function workSetupForSelection(cwd: string, selection: IntentSelection): Promise<RecordedWorkSetup | null> {
-  const path=join(resolve(cwd),".pi","work-setups",`${selection.snapshot.digest}.json`),value=await readProductJson(path) as RecordedWorkSetup|null;
-  if(!value)return null;
-  if(value.state?.statePath!==join(resolve(cwd),".pi","work-current.json")||intentKey(value.state.selectedSnapshot)!==intentKey(selection))throw Error("recorded selection labels mismatch");
-  return loadWorkSetup(value.state);
-}
-export async function workPresentation(state: DeclaredWorkState): Promise<WorkPresentation | null> {
-  const setup = await loadWorkSetup(state);
-  if (setup) return { outcome: setup.setup.outcome, obligations: setup.tasks.map(t => { const spec = setup.setup.tasks.find(s => s.id === t.id)!; return { digest: t.obligation.digest, outcome: spec.outcome, agent: spec.agent ?? "No-tool agent", dependencies: spec.dependencies }; }) };
-  const value = await readProductJson(join(dirname(state.statePath), "work-outcomes", `${state.outcomeDigest}.json`)) as { outcome: string } | null;
-  if (!value) return null;
-  if (Object.keys(value).join() !== "outcome" || typeof value.outcome !== "string" || hash(value.outcome.trim()) !== state.outcomeDigest) throw Error("declared outcome digest mismatch");
-  return { outcome: value.outcome, obligations: [{ digest: state.obligation.digest, outcome: value.outcome }] };
-}

package/src/workflow-fact-id.ts

@@ -1,16 +0,0 @@
-const WORKFLOW_FACT_ID_RE = /^fact:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-const WORKFLOW_IDENTIFIER_RE = /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$/;
-
-export function isWorkflowFactId(value: unknown): value is string {
-  return typeof value === "string" && WORKFLOW_FACT_ID_RE.test(value);
-}
-
-export function isWorkflowIdentifier(value: unknown): value is string {
-  return typeof value === "string" && WORKFLOW_IDENTIFIER_RE.test(value);
-}
-
-export function workflowFactStateMatches(provenance: unknown, state: unknown): boolean {
-  return (provenance === "planned" && state === "pending") ||
-    (provenance === "observed" && state === "observed") ||
-    (provenance === "controller_validated" && ["started", "completed", "blocked"].includes(String(state)));
-}

package/src/workflow-facts.ts

@@ -1,65 +0,0 @@
-import { LEDGER_VERSION } from "./ledger.ts";
-import { normaliseCorrelation, type CorrelationMetadata } from "./correlation.ts";
-import { isWorkflowFactId, isWorkflowIdentifier, workflowFactStateMatches } from "./workflow-fact-id.ts";
-import { assertLedgerV3Wire } from "./ledger-v3-validation.ts";
-
-export const WORKFLOW_FACT_PROVENANCE = ["planned", "observed", "controller_validated"] as const;
-export type WorkflowFactProvenance = typeof WORKFLOW_FACT_PROVENANCE[number];
-export const WORKFLOW_FACT_KINDS = ["workflow_phase", "inline_skill", "transition"] as const;
-export type WorkflowFactKind = typeof WORKFLOW_FACT_KINDS[number];
-export const WORKFLOW_FACT_STATES = ["pending", "observed", "started", "completed", "blocked"] as const;
-export type WorkflowFactState = typeof WORKFLOW_FACT_STATES[number];
-
-export interface WorkflowFactEvent {
-  ledgerVersion: typeof LEDGER_VERSION;
-  event: "workflow_fact";
-  ts: string;
-  factId: string;
-  /** Package/controller identifier, not free-form display text. */
-  source: string;
-  provenance: WorkflowFactProvenance;
-  kind: WorkflowFactKind;
-  /** Phase, skill, or transition identifier. Never task text. */
-  subject: string;
-  state: WorkflowFactState;
-  /** run_id is required by the builder; other values remain non-authoritative labels. */
-  correlation: CorrelationMetadata;
-}
-
-export function buildWorkflowFactEvent(args: {
-  factId: string;
-  source: string;
-  provenance: WorkflowFactProvenance;
-  kind: WorkflowFactKind;
-  subject: string;
-  state: WorkflowFactState;
-  correlation: CorrelationMetadata;
-  now: Date;
-}): WorkflowFactEvent {
-  if (!isWorkflowFactId(args.factId)) throw new TypeError("factId must be a pi-daddy workflow fact id");
-  if (!isWorkflowIdentifier(args.source)) throw new TypeError("workflow fact source must be an identifier");
-  if (!WORKFLOW_FACT_PROVENANCE.includes(args.provenance)) throw new TypeError("workflow fact provenance is not recognised");
-  if (!WORKFLOW_FACT_KINDS.includes(args.kind)) throw new TypeError("workflow fact kind is not recognised");
-  if (!isWorkflowIdentifier(args.subject)) throw new TypeError("workflow fact subject must be an identifier, not task text");
-  if (!WORKFLOW_FACT_STATES.includes(args.state)) throw new TypeError("workflow fact state is not recognised");
-  const correlation = normaliseCorrelation(args.correlation);
-  if (!correlation?.run_id) throw new TypeError("workflow facts require correlation.run_id");
-  if (!workflowFactStateMatches(args.provenance, args.state)) {
-    const expected = args.provenance === "planned" ? "pending" : args.provenance === "observed"
-      ? "observed" : "started, completed, or blocked";
-    throw new TypeError(`${args.provenance.replaceAll("_", "-")} workflow facts must use ${expected}`);
-  }
-  const event: WorkflowFactEvent = {
-    ledgerVersion: LEDGER_VERSION,
-    event: "workflow_fact",
-    ts: args.now.toISOString(),
-    factId: args.factId,
-    source: args.source,
-    provenance: args.provenance,
-    kind: args.kind,
-    subject: args.subject,
-    state: args.state,
-    correlation,
-  };
-  return assertLedgerV3Wire(event);
-}