@goah/cli 0.10.2 → 0.11.0

package/node_modules/goah-supervisor/dist/index.js

@@ -94,16 +94,32 @@ export class Supervisor {
     }
     get runner() { return this.#runner; }
     createGoal(goal, actor = "human") { this.ledger.putGoal(goal, actor); }
-    startGoal(objective, id = randomUUID()) {
+    createRootGoal(objective, id = randomUUID()) {
         if (!objective.trim())
             throw new Error("root objective is required");
-        const goal = { id, parentId: null, objective, observationMethod: null, owner: "ceo", phase: "active", revision: 0 };
+        if (this.ledger.goals().some((goal) => goal.parentId === null && goal.owner === "ceo" && goal.phase !== "complete"))
+            throw new Error("CEO already has an unfinished Root Goal; use work_on_goal");
+        const goal = { id, parentId: null, objective, observationMethod: null, verificationMethod: null, owner: "ceo", phase: "active", revision: 0 };
         this.ledger.putGoal(goal, "human");
+        return this.#goal(id);
+    }
+    startGoal(objective, id = randomUUID()) {
+        const goal = this.createRootGoal(objective, id);
         const wake = this.#enqueueTrigger("ceo", `root:${id}:created`);
         if (!wake)
             throw new Error("CEO wake was not admitted for an active root goal");
         return { goal, wake };
     }
+    interactWithCeo(message) {
+        if (!message.trim())
+            throw new Error("message is required");
+        const mail = { id: randomUUID(), to: "ceo", from: "human", level: "fyi", body: { type: "interaction", message }, readAt: null };
+        this.ledger.putMail(mail, "human");
+        const wake = this.#enqueueTrigger("ceo", `interaction:${mail.id}`);
+        if (!wake)
+            throw new Error("CEO interaction was not admitted");
+        return { mail, wake };
+    }
     sendToCeo(body, level = "decision") {
         const mail = { id: randomUUID(), to: "ceo", from: "human", level, body, readAt: null };
         this.ledger.putMail(mail, "human");
@@ -116,15 +132,16 @@ export class Supervisor {
     reassignGoal(request, actor = "ceo", wakeId) { return this.ledger.commitReassignment(request, actor, wakeId); }
     teamList(now = this.#now()) { return deriveTeam(this.ledger, now); }
     updateGoal(id, patch, actor = "human") {
-        if (patch.objective === undefined && patch.observationMethod === undefined && patch.owner === undefined)
-            throw new Error("goal update requires objective, observation method, or owner");
+        if (patch.objective === undefined && patch.observationMethod === undefined && patch.verificationMethod === undefined && patch.owner === undefined)
+            throw new Error("goal update requires objective, observation method, verification method, or owner");
         const current = this.#goal(id);
-        if (patch.objective !== undefined && patch.objective !== current.objective && current.parentId !== null && patch.observationMethod === undefined)
-            throw new Error("child objective revision requires a replacement observation method");
+        if (patch.objective !== undefined && patch.objective !== current.objective && current.parentId !== null && (patch.observationMethod === undefined || patch.verificationMethod === undefined))
+            throw new Error("child objective revision requires replacement observation and verification methods");
         const next = {
             ...current,
             ...patch,
             ...(patch.objective !== undefined && patch.objective !== current.objective && current.parentId === null && patch.observationMethod === undefined ? { observationMethod: null } : {}),
+            ...(patch.objective !== undefined && patch.objective !== current.objective && current.parentId === null && patch.verificationMethod === undefined ? { verificationMethod: null } : {}),
             revision: current.revision + 1,
         };
         this.ledger.putGoal(next, actor);
@@ -136,9 +153,9 @@ export class Supervisor {
         const current = this.#goal(id);
         if (current.parentId !== null)
             throw new Error("human confirmation applies only to a root goal");
-        return this.updateGoal(id, { observationMethod }, "human");
+        return this.updateGoal(id, { observationMethod, verificationMethod: observationMethod }, "human");
     }
-    reviseChildGoal(id, objective, observationMethod, actor, reason, evidence, wakeId) {
+    reviseChildGoal(id, objective, observationMethod, verificationMethod, actor, reason, evidence, wakeId) {
         const current = this.#goal(id);
         if (current.parentId === null)
             throw new Error("CEO cannot revise a root goal");
@@ -147,8 +164,8 @@ export class Supervisor {
         for (const seq of evidence)
             if (!this.ledger.eventsSince(seq - 1).some((event) => event.seq === seq))
                 throw new Error(`evidence event does not exist: ${seq}`);
-        this.ledger.appendEvent({ streamId: wakeId ? wakeStream(wakeId) : goalStream(id), ts: this.#now(), actor, type: "goal.revision_requested", data: { goalId: id, fromRevision: current.revision, objective, observationMethod, reason, evidence } });
-        return this.updateGoal(id, { objective, observationMethod }, actor);
+        this.ledger.appendEvent({ streamId: wakeId ? wakeStream(wakeId) : goalStream(id), ts: this.#now(), actor, type: "goal.revision_requested", data: { goalId: id, fromRevision: current.revision, objective, observationMethod, verificationMethod, reason, evidence } });
+        return this.updateGoal(id, { objective, observationMethod, verificationMethod }, actor);
     }
     completeGoal(request, actor = "human", wakeId) {
         const goal = this.ledger.completeGoal(request, actor, wakeId);
@@ -212,13 +229,17 @@ export class Supervisor {
         let renewal;
         try {
             running = this.ledger.markWakeRunning(wake.id, this.#now(), leaseToken);
-            const context = this.#loadContext(running);
+            const turn = this.#turnContext(running);
+            this.ledger.appendRunnerEvent({ streamId: wakeStream(running.id), ts: this.#now(), actor: running.agent, type: "run.admitted", data: turn }, leaseToken);
+            const workRecordRevisionAtStart = turn.goalBinding ? this.ledger.workRecord(turn.goalBinding.goalId)?.recordRevision ?? -1 : -1;
+            const context = this.#loadContext(running, turn);
             handle = this.runner.prepare({
                 wake: running,
+                turn,
                 context,
                 now: () => this.#now(),
                 emit: (trace) => this.ledger.appendRunnerEvent({ streamId: wakeStream(running.id), ts: this.#now(), actor: running.agent, type: trace.type, data: trace.data }, leaseToken),
-                rpc: (method, params) => this.#agentRpc(running, leaseToken, method, params),
+                rpc: (method, params) => this.#agentRpc(running, turn, leaseToken, method, params),
             });
             this.#handles.set(running.id, handle);
             if (handle.pid)
@@ -243,14 +264,27 @@ export class Supervisor {
                 await this.#markAbnormal(running, result.reason);
                 return this.#wake(running.id);
             }
-            this.#validateCeoHandoff(running, result.output);
-            const outgoingMail = result.output.mail.map((draft) => ({ id: randomUUID(), to: draft.to, from: running.agent, level: draft.level, body: draft.body, readAt: null }));
-            const schedule = result.output.nextWakeAt
-                ? { id: `schedule:${running.agent}`, agent: running.agent, nextWakeAt: result.output.nextWakeAt, reason: "handoff.next_steps", setBy: running.agent }
+            if (result.outcome === "response") {
+                if (turn.goalBinding)
+                    throw new Error("a Goal-bound Turn must finish with a handoff");
+                const mailId = interactionMailId(running);
+                if (!mailId)
+                    throw new Error("an ordinary response requires an interaction mail");
+                this.ledger.commitInteraction({ agent: running.agent, wakeId: running.id, mailId, ts: this.#now(), response: result.response });
+                this.ledger.finishWake(running.id, "done", this.#now());
+                return this.#wake(running.id);
+            }
+            if (turn.goalBinding)
+                this.#validateGoalTurnRecord(running, turn, workRecordRevisionAtStart);
+            const output = turn.goalBinding ? this.#goalWakeOutput(result.output, turn.goalBinding) : result.output;
+            this.#validateCeoHandoff(running, output);
+            const outgoingMail = output.mail.map((draft) => ({ id: randomUUID(), to: draft.to, from: running.agent, level: draft.level, body: draft.body, readAt: null }));
+            const schedule = output.nextWakeAt
+                ? { id: `schedule:${running.agent}`, agent: running.agent, nextWakeAt: output.nextWakeAt, reason: "handoff.next_steps", setBy: running.agent }
                 : null;
-            const handoffEvent = this.ledger.commitHandoff({ agent: running.agent, wakeId: running.id, ts: this.#now(), output: result.output, outgoingMail, schedule });
+            const handoffEvent = this.ledger.commitHandoff({ agent: running.agent, wakeId: running.id, ts: this.#now(), output, outgoingMail, schedule });
             this.ledger.finishWake(running.id, "done", this.#now());
-            if (this.#role(running.agent) !== "ceo" && (result.output.handoff.material || result.output.handoff.blocker) && this.#hasActiveRoot()) {
+            if (this.#role(running.agent) !== "ceo" && handoffTriggersCeo(output.handoff) && this.#hasActiveRoot()) {
                 this.#enqueueTrigger("ceo", `child-handoff:${handoffEvent.seq}`);
             }
             if (this.#verifyMetricsAfterWake) {
@@ -416,10 +450,10 @@ export class Supervisor {
         if (exact)
             return exact;
         const ownsLiveGoal = this.ledger.goalsForOwner(agent).some((goal) => goal.phase === "active" || goal.phase === "blocked");
-        const ceoInterrupt = agent === "ceo" && (triggerRef.startsWith("mail:") || triggerRef.startsWith("child-"));
+        const ceoInterrupt = agent === "ceo" && (triggerRef.startsWith("interaction:") || triggerRef.startsWith("mail:") || triggerRef.startsWith("child-"));
         if (!ownsLiveGoal && !ceoInterrupt)
             return null;
-        const queued = this.ledger.queuedWakeForAgent(agent);
+        const queued = triggerRef.startsWith("interaction:") ? null : this.ledger.queuedWakeForAgent(agent);
         if (queued) {
             this.ledger.appendEvent({ streamId: wakeStream(queued.id), ts: this.#now(), actor: "supervisor", type: "wake.trigger_coalesced", data: { wakeId: queued.id, triggerRef } });
             return queued;
@@ -450,7 +484,7 @@ export class Supervisor {
         const activeRoot = this.#hasActiveRoot();
         const hasChildMotion = this.teamList().some((member) => member.agent !== "ceo" && !["idle_unplanned", "retired"].includes(member.status));
         const hasReview = Boolean(output.nextWakeAt);
-        const hasBlocker = Boolean(output.handoff.blocker);
+        const hasBlocker = handoffBlocked(output.handoff);
         const asksHuman = output.mail.some((mail) => mail.to === "human" && (mail.level === "decision" || mail.level === "emergency"))
             || this.ledger.unreadMail("human").some((mail) => mail.from === "ceo" && (mail.level === "decision" || mail.level === "emergency"));
         if (idle.length === 0 && missingObservationGoalIds.length === 0 && (!activeRoot || hasChildMotion || hasReview || hasBlocker || asksHuman))
@@ -463,10 +497,61 @@ export class Supervisor {
         this.ledger.appendEvent({ streamId: wakeStream(wake.id), ts: this.#now(), actor: "supervisor", type: "ceo.motion_invalid", data: violation });
         throw new Error(`CEO motion invalid: ${violation.reason}${violation.idleAgents.length ? ` (${violation.idleAgents.join(", ")})` : ""}`);
     }
-    #loadContext(wake) {
+    #validateGoalTurnRecord(wake, turn, revisionAtStart) {
+        const binding = turn.goalBinding;
+        const goal = this.#goal(binding.goalId);
+        if (goal.revision !== binding.goalRevision)
+            throw new Error("Goal revision changed during the Turn");
+        const record = this.ledger.workRecord(goal.id);
+        if (!record || record.recordRevision <= revisionAtStart || record.updatedInTurn !== wake.id || record.goalRevision !== goal.revision)
+            throw new Error("Goal-bound Turn must update its Work Record before handoff");
+    }
+    #goalWakeOutput(output, binding) {
+        const record = this.ledger.workRecord(binding.goalId);
+        if (!record)
+            throw new Error("Goal Work Record is missing");
+        const legacy = "goalId" in output.handoff ? null : output.handoff;
+        const handoff = {
+            goalId: binding.goalId,
+            goalRevision: binding.goalRevision,
+            recordRevision: record.recordRevision,
+            outcome: "goalId" in output.handoff ? output.handoff.outcome : legacy?.blocker ? "blocked" : legacy?.material ? "completion_proposed" : "progress",
+            evidence: "goalId" in output.handoff && output.handoff.evidence.length ? output.handoff.evidence : record.evidence,
+        };
+        return { ...output, handoff };
+    }
+    #turnContext(wake) {
+        if (interactionMailId(wake))
+            return { source: { kind: "human" } };
+        const goals = this.ledger.goalsForOwner(wake.agent).filter((goal) => goal.phase === "active");
+        const goal = goals.find((candidate) => candidate.parentId === null) ?? goals[0];
+        const humanMail = wake.triggerRef.startsWith("mail:") && this.ledger.mailbox().some((mail) => mail.id === wake.triggerRef.slice(5) && mail.from === "human");
+        return { source: humanMail ? { kind: "human" } : { kind: "goal_driver", round: goal ? (this.ledger.workRecord(goal.id)?.recordRevision ?? 0) + 1 : 1 }, ...(goal ? { goalBinding: { goalId: goal.id, goalRevision: goal.revision } } : {}) };
+    }
+    #loadContext(wake, turn) {
         const profile = this.#profiles.get(wake.agent) ?? { agent: wake.agent, role: "child" };
         const role = profile.role;
         const capabilities = profile.capabilities ?? defaultCapabilities(role);
+        const runnerProfile = this.#runnerProfiles.get(profile.runnerProfile ?? "default");
+        if (!turn.goalBinding && interactionMailId(wake)) {
+            const mail = this.ledger.mailbox().find((candidate) => candidate.id === interactionMailId(wake));
+            const body = mail?.body && typeof mail.body === "object" && !Array.isArray(mail.body) ? mail.body : {};
+            const message = typeof body.message === "string" ? body.message : "";
+            const mailEvent = this.ledger.eventsSince(0, ["mail.put"]).findLast((event) => event.data.snapshot?.id === mail?.id);
+            const recent = this.ledger.eventsSince(0, ["interaction.completed"]).filter((event) => event.actor === wake.agent).slice(-8).map((event) => {
+                const data = event.data;
+                const prior = this.ledger.mailbox().find((candidate) => candidate.id === data.mailId);
+                const priorBody = prior?.body && typeof prior.body === "object" && !Array.isArray(prior.body) ? prior.body : {};
+                return `Human: ${typeof priorBody.message === "string" ? priorBody.message : ""}\nAssistant: ${data.response?.content ?? ""}`;
+            });
+            return {
+                text: [...(recent.length ? [`# Recent conversation\n\n${recent.join("\n\n")}`] : []), `# Human message\n\n${message}`].join("\n\n"),
+                sourceSeqs: mailEvent ? [mailEvent.seq] : [],
+                capabilities,
+                systemPrompt: profile.systemPrompt ?? "You are Goah's primary Agent. Respond naturally to the Human, use tools when useful, and keep the final answer concise. Do not create or operate a Goal unless the Human expresses durable Goal intent.",
+                ...(runnerProfile ? { runnerProfile } : {}),
+            };
+        }
         const goals = role === "ceo" ? this.ledger.goals() : this.ledger.goalsForOwner(wake.agent);
         const mail = this.ledger.unreadMail(wake.agent);
         const handoff = this.ledger.lastEvent(wake.agent, "handoff.recorded");
@@ -480,8 +565,14 @@ export class Supervisor {
         const actions = this.ledger.actions().filter((action) => action.agent === wake.agent && (action.status === "unknown" || Boolean(action.auditAdvice && !action.adviceAcked)));
         const revisionWarnings = goals.flatMap((goal) => this.#goalRevisionWarning(goal));
         const workingMemory = selectWorkingMemory(this.ledger.readStream(memoryStream(wake.agent)), this.#memoryTailChars);
-        const runnerProfile = this.#runnerProfiles.get(profile.runnerProfile ?? "default");
-        return { ...composeActiveContext({ role, capabilities, systemPrompt: profile.systemPrompt ?? defaultRolePrompt(role), wake, goals, mail, actions, lastHandoff: handoff, teamHandoffs, team: role === "ceo" ? this.teamList() : [], revisionWarnings, recoveryEvents, workingMemory }), ...(runnerProfile ? { runnerProfile } : {}) };
+        const active = composeActiveContext({ role, capabilities, systemPrompt: profile.systemPrompt ?? defaultRolePrompt(role), wake, goals, mail, actions, lastHandoff: handoff, teamHandoffs, team: role === "ceo" ? this.teamList() : [], revisionWarnings, recoveryEvents, workingMemory });
+        const records = this.ledger.workRecords();
+        const currentRecord = turn.goalBinding ? this.ledger.workRecord(turn.goalBinding.goalId) : null;
+        const currentGoal = turn.goalBinding ? this.ledger.goal(turn.goalBinding.goalId) : null;
+        const parentRecord = currentGoal?.parentId ? this.ledger.workRecord(currentGoal.parentId) : null;
+        const recordIndex = records.map((record) => `- /goals/${record.goalId}.md · r${record.recordRevision} · ${this.ledger.goal(record.goalId)?.owner ?? "unknown"} · ${this.ledger.goal(record.goalId)?.phase ?? "unknown"}`);
+        const workText = [`# Shared Work Record Index\n\n${recordIndex.join("\n")}`, ...(currentRecord ? [`# Your Work Record\n\n${currentRecord.content}`] : []), ...(parentRecord ? [`# Parent Work Record\n\n${parentRecord.content}`] : [])].join("\n\n");
+        return { ...active, text: `${active.text}\n\n${workText}`, sourceSeqs: [...new Set([...active.sourceSeqs, ...records.map((record) => record.lastEventSeq)])].sort((a, b) => a - b), workRecord: currentRecord, sharedWorkRecords: records, ...(runnerProfile ? { runnerProfile } : {}) };
     }
     #requiredConnector(name) { const value = this.#connectors.get(name); if (!value)
         throw new Error(`connector not registered: ${name}`); return value; }
@@ -507,7 +598,7 @@ export class Supervisor {
             throw new Error(warnings.join(" "));
     }
     #now() { return this.clock.now().toISOString(); }
-    async #agentRpc(wake, leaseToken, method, params) {
+    async #agentRpc(wake, turn, leaseToken, method, params) {
         const current = this.ledger.wake(wake.id);
         if (!current || current.status !== "running" || current.leaseToken !== leaseToken || !current.leaseUntil || current.leaseUntil < this.#now())
             throw new Error("stale runner RPC rejected");
@@ -515,12 +606,51 @@ export class Supervisor {
         const allowed = new Set(profile.capabilities ?? defaultCapabilities(profile.role));
         if (!allowed.has(method))
             throw new Error(`${profile.role} agent is not allowed to call ${method}`);
+        if (!turn.goalBinding && goalBoundCapability(method))
+            throw new Error(`${method} requires a Goal-bound Turn`);
         this.ledger.appendRunnerEvent({ streamId: wakeStream(wake.id), ts: this.#now(), actor: wake.agent, type: `rpc.${method}`, data: params }, leaseToken);
         const input = asRecord(params);
         if (method === "ledger.search")
             return this.ledger.searchEvents(String(input.query), Number(input.limit ?? 20));
         if (method === "team.list")
             return this.teamList();
+        if (method === "goal.get")
+            return (turn.goalBinding ? this.ledger.goal(turn.goalBinding.goalId) : null);
+        if (method === "goal.create") {
+            if (turn.source.kind !== "human" || turn.goalBinding)
+                throw new Error("a Root Goal can only be created from an unbound Human Turn");
+            if (wake.agent !== "ceo")
+                throw new Error("only CEO may translate Human intent into a Root Goal");
+            const goal = this.createRootGoal(String(input.objective), typeof input.id === "string" && input.id.trim() ? input.id : undefined);
+            turn.goalBinding = { goalId: goal.id, goalRevision: goal.revision };
+            this.ledger.appendRunnerEvent({ streamId: wakeStream(wake.id), ts: this.#now(), actor: wake.agent, type: "turn.goal_bound", data: { goalId: goal.id, goalRevision: goal.revision, authority: "human" } }, leaseToken);
+            return { goal, goalBinding: turn.goalBinding, instruction: "This Turn is now Goal-bound. Update its Work Record and finish with handoff." };
+        }
+        if (method === "goal.work") {
+            if (turn.source.kind !== "human" || turn.goalBinding)
+                throw new Error("work_on_goal requires an unbound Human Turn");
+            const goal = this.#goal(String(input.goalId));
+            if (goal.owner !== wake.agent || goal.phase !== "active")
+                throw new Error("work_on_goal requires an active Goal owned by this Agent");
+            turn.goalBinding = { goalId: goal.id, goalRevision: goal.revision };
+            this.ledger.appendRunnerEvent({ streamId: wakeStream(wake.id), ts: this.#now(), actor: wake.agent, type: "turn.goal_bound", data: { goalId: goal.id, goalRevision: goal.revision, authority: "human" } }, leaseToken);
+            return { goal, goalBinding: turn.goalBinding, instruction: "This Turn is now Goal-bound. Update its Work Record and finish with handoff." };
+        }
+        if (method === "work_record.list")
+            return this.ledger.workRecords();
+        if (method === "work_record.read")
+            return this.ledger.workRecord(String(input.goalId ?? turn.goalBinding?.goalId ?? ""));
+        if (method === "work_record.history")
+            return this.ledger.workRecordHistory(String(input.goalId ?? turn.goalBinding?.goalId ?? ""));
+        if (method === "work_record.diff")
+            return this.ledger.workRecordDiff(String(input.goalId ?? turn.goalBinding?.goalId ?? ""), Number(input.fromRevision), Number(input.toRevision));
+        if (method === "work_record.search")
+            return this.ledger.searchWorkRecords(String(input.query), Number(input.limit ?? 20));
+        if (method === "work_record.update") {
+            if (!turn.goalBinding)
+                throw new Error("work_record.update requires a Goal-bound Turn");
+            return this.ledger.updateWorkRecord({ goalId: turn.goalBinding.goalId, goalRevision: turn.goalBinding.goalRevision, expectedRevision: Number(input.expectedRevision), content: String(input.content), reason: String(input.reason), evidence: numberArray(input.evidence), turnId: wake.id, wakeId: wake.id }, wake.agent);
+        }
         if (method === "goal.delegate")
             return this.delegate({
                 id: String(input.id),
@@ -540,11 +670,28 @@ export class Supervisor {
                 evidence: numberArray(input.evidence),
             }, wake.agent, wake.id);
         if (method === "goal.revise")
-            return this.reviseChildGoal(String(input.goalId), String(input.objective), String(input.observationMethod), wake.agent, String(input.reason), numberArray(input.evidence), wake.id);
-        if (method === "goal.pause" || method === "goal.resume")
-            return this.transitionGoal(String(input.goalId), method === "goal.pause" ? "paused" : "active", wake.agent);
-        if (method === "goal.complete")
-            return this.completeGoal({ goalId: String(input.goalId), revision: Number(input.revision), reason: String(input.reason), evidence: numberArray(input.evidence) }, wake.agent, wake.id);
+            return this.reviseChildGoal(String(input.goalId), String(input.objective), String(input.observationMethod), String(input.verificationMethod), wake.agent, String(input.reason), numberArray(input.evidence), wake.id);
+        if (method === "goal.pause" || method === "goal.resume") {
+            const goalId = String(input.goalId);
+            const currentGoal = this.#goal(goalId);
+            const directHumanRoot = !turn.goalBinding && turn.source.kind === "human" && currentGoal.parentId === null;
+            if (!turn.goalBinding && !directHumanRoot)
+                throw new Error(`${method} requires a Goal-bound Turn`);
+            const goal = this.transitionGoal(goalId, method === "goal.pause" ? "paused" : "active", directHumanRoot ? "human" : wake.agent);
+            if (method === "goal.resume" && directHumanRoot) {
+                turn.goalBinding = { goalId: goal.id, goalRevision: goal.revision };
+                this.ledger.appendRunnerEvent({ streamId: wakeStream(wake.id), ts: this.#now(), actor: wake.agent, type: "turn.goal_bound", data: { goalId: goal.id, goalRevision: goal.revision, authority: "human" } }, leaseToken);
+                return { goal, goalBinding: turn.goalBinding, instruction: "This Turn is now Goal-bound. Update its Work Record and finish with handoff." };
+            }
+            return goal;
+        }
+        if (method === "goal.complete") {
+            const currentGoal = this.#goal(String(input.goalId));
+            const directHumanRoot = !turn.goalBinding && turn.source.kind === "human" && currentGoal.parentId === null;
+            if (!turn.goalBinding && !directHumanRoot)
+                throw new Error("goal.complete requires a Goal-bound Turn");
+            return this.completeGoal({ goalId: currentGoal.id, revision: Number(input.revision), reason: String(input.reason), evidence: numberArray(input.evidence) }, directHumanRoot ? "human" : wake.agent, wake.id);
+        }
         if (method === "human.request") {
             const evidence = numberArray(input.evidence);
             for (const seq of evidence)
@@ -648,7 +795,7 @@ export function deriveTeam(ledger, now = new Date().toISOString()) {
         const nextWakeAt = schedules.filter((schedule) => schedule.agent === agent && schedule.nextWakeAt > now).map((schedule) => schedule.nextWakeAt).sort()[0] ?? null;
         const lastHandoff = [...handoffs].reverse().find((event) => event.actor === agent) ?? null;
         const blocker = lastHandoff && typeof lastHandoff.data === "object" && lastHandoff.data !== null && !Array.isArray(lastHandoff.data)
-            ? lastHandoff.data.blocker
+            ? (lastHandoff.data.blocker ?? (lastHandoff.data.outcome === "blocked" ? "blocked" : null))
             : null;
         let status;
         if (live.length === 0)
@@ -715,22 +862,26 @@ function minimalEnvironment(explicit = {}) {
     return { ...env, ...explicit };
 }
 function escapeHtml(value) { return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;"); }
+function interactionMailId(wake) { return wake.triggerRef.startsWith("interaction:") ? wake.triggerRef.slice("interaction:".length) : null; }
+function handoffBlocked(handoff) { return "goalId" in handoff ? handoff.outcome === "blocked" : Boolean(handoff.blocker); }
+function handoffTriggersCeo(handoff) { return "goalId" in handoff ? handoff.outcome === "blocked" || handoff.outcome === "completion_proposed" : Boolean(handoff.material || handoff.blocker); }
+function goalBoundCapability(method) { return ["goal.delegate", "goal.reassign", "goal.revise", "goal.put", "work_record.update", "mail.send", "schedule.set", "human.request"].includes(method); }
 function asRecord(value) { if (typeof value !== "object" || value === null || Array.isArray(value))
     throw new Error("RPC params must be an object"); return value; }
 function numberArray(value) { if (!Array.isArray(value) || value.some((item) => typeof item !== "number"))
     throw new Error("RPC evidence must be a number array"); return value; }
 function asChildGoal(value) {
     const input = asRecord(value ?? null);
-    return { id: String(input.id), objective: String(input.objective), observationMethod: String(input.observationMethod), owner: String(input.owner) };
+    return { id: String(input.id), objective: String(input.objective), observationMethod: String(input.observationMethod), verificationMethod: String(input.verificationMethod), owner: String(input.owner) };
 }
 function defaultCapabilities(role) {
     if (role === "ceo")
-        return ["ledger.search", "mail.send", "schedule.set", "action.submit", "audit.ack", "memory.append", "team.list", "goal.delegate", "goal.reassign", "goal.revise", "goal.pause", "goal.resume", "goal.complete", "human.request"];
+        return ["ledger.search", "mail.send", "schedule.set", "action.submit", "audit.ack", "team.list", "goal.get", "goal.create", "goal.work", "goal.delegate", "goal.reassign", "goal.revise", "goal.pause", "goal.resume", "goal.complete", "human.request", "work_record.list", "work_record.read", "work_record.history", "work_record.diff", "work_record.search", "work_record.update"];
     if (role === "verifier")
         return ["ledger.search", "mail.send", "memory.append", "audit.write"];
     if (role === "audit")
         return ["ledger.search", "mail.send", "memory.append", "audit.write"];
-    return ["ledger.search", "mail.send", "schedule.set", "action.submit", "audit.ack", "memory.append"];
+    return ["ledger.search", "mail.send", "schedule.set", "action.submit", "audit.ack", "goal.get", "work_record.list", "work_record.read", "work_record.history", "work_record.diff", "work_record.search", "work_record.update"];
 }
 export * from "./verification.js";
 export * from "./roles.js";