mirror of
https://github.com/wassname/pi-goals.git
synced 2026-09-25 14:01:03 +08:00
1085 lines
72 KiB
TypeScript
1085 lines
72 KiB
TypeScript
// Pi/OpenAI: Plan and supervise in the main chat; delegate implementation to a visible worker.
|
|
import { execFileSync } from "node:child_process";
|
|
import { createHash, randomUUID } from "node:crypto";
|
|
import { type FSWatcher, mkdirSync, readdirSync, readFileSync, watch, writeFileSync } from "node:fs";
|
|
import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
|
|
import { fileURLToPath } from "node:url";
|
|
import { type ExtensionAPI, type ExtensionContext, getMarkdownTheme, keyHint, SessionManager, withFileMutationQueue } from "@earendil-works/pi-coding-agent";
|
|
import { Markdown, truncateToWidth } from "@earendil-works/pi-tui";
|
|
import { INTERCOM_EXTENSION_REGISTER_EVENT, type IntercomExtensionChannel, type IntercomExtensionRegistration } from "pi-intercom/extension-api.js";
|
|
import { openProjectPane } from "pi-subagents/project-panes";
|
|
import { Type } from "typebox";
|
|
import { noticeDisplay } from "./notice-display.js";
|
|
import { FOLD_LINE, foldPlan, GOAL_LINE, planRequirements as requirements } from "./plan.js";
|
|
import { planViews } from "./plan-view.js";
|
|
import {
|
|
attachGoalPlanDescription,
|
|
childPlanAttached,
|
|
childPlanRole,
|
|
completeGoalDescription,
|
|
completionLog,
|
|
completionResult,
|
|
discuss,
|
|
emptyEvidence,
|
|
evidenceUnavailable,
|
|
finalReview,
|
|
finalReviewInvalidated,
|
|
finalReviewQueued,
|
|
goalToolBlocked,
|
|
manualReview,
|
|
messages,
|
|
nativeMessages,
|
|
pausedRole,
|
|
pauseExitNotice,
|
|
pendingReportReviews,
|
|
planActivityRecorded,
|
|
planChangedReview,
|
|
planContext,
|
|
planDocument,
|
|
planning,
|
|
planningSeed,
|
|
planReviewResult,
|
|
planUnavailable,
|
|
readyApproved,
|
|
removeGoalSchedule,
|
|
reportGoalEventDescription,
|
|
reportReviewContent,
|
|
reportReviewDescription,
|
|
requestPlanReviewDescription,
|
|
resumeNotice,
|
|
scheduleCheckIn,
|
|
schedulerMessages,
|
|
soloNotice,
|
|
soloRole,
|
|
supervisor,
|
|
upkeep,
|
|
workerAssignment,
|
|
workerAttachment,
|
|
workerStatus,
|
|
workerViewDescription,
|
|
workerViewText,
|
|
workerViewUnavailable,
|
|
} from "./prompts.js";
|
|
import { buildWorkerView, descendantProcesses, viewClip } from "./worker-view.js";
|
|
|
|
const STATE = "pi-goals-main-supervisor-v1";
|
|
const WORKER = "goals-worker";
|
|
const REPORT = "pi-goals-report", REVIEW = "pi-goals-report-review", REVIEW_DRAFT = "pi-goals-review-draft", REVIEW_REMINDER = "pi-goals-review-reminder";
|
|
const RUN = "pi-goals-worker-run", STOP = "pi-goals-worker-stop", WORKER_EVENT = "pi-goals-worker-event", WORKER_RELEASE = "pi-goals-worker-release";
|
|
type GoalEventKind = "review_request" | "decision" | "blocker" | "completion" | "progress" | "running" | "waiting" | "receipt" | "no_change" | "aborted" | "unclassified";
|
|
// Formal review is the supervisor's choice only for a potential stop; steering and in-flight plan edits need no form. — wassname
|
|
const POTENTIAL_STOP_EVENTS = new Set<GoalEventKind>(["review_request", "blocker", "completion", "aborted", "unclassified"]);
|
|
const ATTENTION_EVENTS = new Set<GoalEventKind>([...POTENTIAL_STOP_EVENTS, "decision"]);
|
|
interface WorkerStop { type: "stopped"; entryId: string; to: string; requestId: string; plan: string; text: string; identity: Peer; kind?: GoalEventKind; }
|
|
interface Report { id: string; plan: string; session: string; sessionFile: string; requestId: string; task?: string; text: string; kind: GoalEventKind; supersedes?: string; }
|
|
type WorkerEvent = Report;
|
|
interface ReportReview { id: string; reportId?: string; report?: string; verdict: string; content: string; continuation: string; }
|
|
const reviewedReportId = (review: ReportReview) => review.reportId ?? review.report;
|
|
const WIDGET_GOAL_LIMIT = 3;
|
|
type Mode = "chat" | "planning" | "supervising" | "paused" | "solo";
|
|
type GoalStatus = "open" | "active" | "reported" | "done" | "cancelled";
|
|
interface Peer {
|
|
sessionId: string; sessionFile: string; paneId: string; model?: string;
|
|
}
|
|
interface State {
|
|
mode: Mode;
|
|
plan?: string;
|
|
worker?: { sessionFile?: string; intercomId?: string; paneId?: string; requestId?: string; parentId?: string; task?: string; identity?: Peer; disconnectRevision?: number };
|
|
parent?: { intercomId: string; requestId: string };
|
|
workerStopped?: boolean;
|
|
pausedFrom?: "solo" | "supervising";
|
|
finalReview?: { planDigest: string };
|
|
child?: boolean;
|
|
pausedCheckIns?: Record<string, string>;
|
|
workerView?: { sessionFile: string; boundary: string; through: string; turns: number; progressKey: string; stale: number };
|
|
}
|
|
interface CheckInTask { id: string; name?: string; action?: string; type?: string; scope?: string; sessionFile?: string; prompt?: string; disabledAt?: string; }
|
|
const SCHEDULER_SOURCE = fileURLToPath(import.meta.resolve("@jl1990/pi-scheduler/extensions/scheduler/index.ts"));
|
|
const initial = (): State => ({ mode: "chat" });
|
|
const digest = (text: string) => createHash("sha256").update(text).digest("hex");
|
|
const key = (text: string) => text.trim().toLowerCase();
|
|
// Read foreign history without SessionManager.open's on-disk legacy migration.
|
|
const savedSession = (path: string) => SessionManager.inMemory(undefined, undefined, readFileSync(path, "utf8").trim().split("\n").map(line => JSON.parse(line)));
|
|
function goals(text: string) {
|
|
return foldPlan(text).split("\n").flatMap((line, index) => {
|
|
const match = GOAL_LINE.exec(line);
|
|
if (!match) return [];
|
|
const box = match[1].toLowerCase();
|
|
return [{ subject: match[2].trim(), status: (box === "✓" ? "done" : box === "x" ? "reported" : box === "/" ? "active" : box === "-" ? "cancelled" : "open") as GoalStatus, index }];
|
|
});
|
|
}
|
|
const result = (text: string) => ({ content: [{ type: "text" as const, text }], details: {} });
|
|
|
|
export default function mainSupervisor(pi: ExtensionAPI) {
|
|
// Stock background helpers can inherit forked history and ambient extensions,
|
|
// but must not restore the owner's goal authority, watcher or transport.
|
|
if (process.env.PI_SUBAGENT_CHILD === "1") return;
|
|
const notices = noticeDisplay(pi);
|
|
let state = initial();
|
|
let generation = 0;
|
|
let workerRevision = 0;
|
|
let finalReviewTurnDigest: string | undefined;
|
|
let preparedRole: string | undefined;
|
|
let opening = false;
|
|
let channel: IntercomExtensionChannel | undefined;
|
|
let liveContext: ExtensionContext | undefined;
|
|
let notice = true;
|
|
let fullPlanContextDue = true;
|
|
let planWatcher: FSWatcher | undefined;
|
|
let planEditTimer: ReturnType<typeof setTimeout> | undefined;
|
|
let planHash = "";
|
|
let planActivityHash = "";
|
|
const syncPlanHashes = (text: string) => {
|
|
const views = planViews(text);
|
|
planHash = digest(views.notify);
|
|
planActivityHash = digest(views.activity);
|
|
};
|
|
const save = () => pi.appendEntry(STATE, structuredClone(state));
|
|
// Missing, empty and failed reads are unavailable snapshots, never an empty authoritative plan.
|
|
const readPlan = () => {
|
|
try {
|
|
if (!state.plan) throw new Error(messages.noPlan);
|
|
const text = readFileSync(state.plan, "utf8");
|
|
if (!text.trim()) throw new Error(messages.emptyPlan);
|
|
return { text };
|
|
} catch (error) { return { error: planUnavailable(state.plan, error) }; }
|
|
};
|
|
const planText = () => {
|
|
const snapshot = readPlan();
|
|
if (snapshot.text === undefined) throw new Error(snapshot.error);
|
|
return snapshot.text;
|
|
};
|
|
const clearChangedFinalReview = (text: string) => {
|
|
if (!state.finalReview || state.finalReview.planDigest === digest(text)) return false;
|
|
state.finalReview = undefined;
|
|
finalReviewTurnDigest = undefined;
|
|
save();
|
|
return true;
|
|
};
|
|
let turnsStale = 0;
|
|
let lastWorkingSet = "";
|
|
let pendingPlanNotice: string | undefined;
|
|
let pendingUpkeep: { generation: number; workingSet: string } | undefined;
|
|
const unfinishedGoals = (text: string) => {
|
|
const lines = foldPlan(text).split("\n");
|
|
return goals(text).filter(g => g.status !== "done" && g.status !== "cancelled").map(g => lines[g.index]).join("\n");
|
|
};
|
|
const checkIn = (ctx: ExtensionContext) => scheduleCheckIn(ctx.sessionManager.getSessionId(), state.plan ?? "", ctx.sessionManager.getSessionFile() ?? "", state.pausedCheckIns);
|
|
const hasScheduleTool = () => pi.getAllTools().some((tool) => tool.name === "schedule_task");
|
|
const ownsCheckIn = (task: CheckInTask, ctx: ExtensionContext) => task.name === `goals-${ctx.sessionManager.getSessionId()}` && task.action === "prompt" && task.scope === "session" && Boolean(task.sessionFile) && task.sessionFile === ctx.sessionManager.getSessionFile();
|
|
let agentRunActive = false;
|
|
let clearCheckIn: { generation: number; sessionFile: string; watcher?: FSWatcher; deadline?: ReturnType<typeof setTimeout>; startDeadline?: () => void } | undefined;
|
|
function cancelCheckInRemoval() {
|
|
clearCheckIn?.watcher?.close(); clearTimeout(clearCheckIn?.deadline); clearCheckIn = undefined;
|
|
}
|
|
let pauseCheckIn = false;
|
|
function ownedCheckInIds(ctx: ExtensionContext) {
|
|
const ids = new Set<string>();
|
|
for (const entry of ctx.sessionManager.getBranch()) {
|
|
const details = entry.type === "custom_message" && entry.customType === "scheduled-task" ? entry.details
|
|
: entry.type === "message" && entry.message.role === "toolResult" && ["schedule_task", "list_scheduled_tasks", "manage_scheduled_task"].includes(entry.message.toolName) ? entry.message.details : undefined;
|
|
const data = details as { task?: CheckInTask; tasks?: CheckInTask[] } | undefined;
|
|
for (const task of data?.task ? [data.task] : data?.tasks ?? []) if (ownsCheckIn(task, ctx)) ids.add(task.id);
|
|
}
|
|
return ids;
|
|
}
|
|
const schedulerCommand = (name: string) => pi.getCommands().find(command => command.source === "extension" && command.sourceInfo?.path === SCHEDULER_SOURCE && (command.name === name || command.name.startsWith(name + ":")))?.name;
|
|
function requestCheckInRemoval(ctx: ExtensionContext) {
|
|
cancelCheckInRemoval();
|
|
const list = schedulerCommand("schedules"), remove = schedulerCommand("schedule-remove");
|
|
const sessionFile = ctx.sessionManager.getSessionFile();
|
|
if (!list || !remove || !sessionFile) { ctx.ui.notify(schedulerMessages.unavailable, "warning"); return false; }
|
|
const cursor = ctx.sessionManager.getLeafId();
|
|
const pending: NonNullable<typeof clearCheckIn> = { generation, sessionFile };
|
|
clearCheckIn = pending;
|
|
const unconfirmed = () => { if (clearCheckIn === pending) { cancelCheckInRemoval(); ctx.ui.notify(schedulerMessages.unconfirmed, "warning"); } };
|
|
try {
|
|
// Passive custom messages are persisted without message_end. Observe only the notification;
|
|
// public getBranch() supplies results, never the session file's bytes.
|
|
pending.watcher = watch(sessionFile, { persistent: false }, (event) => {
|
|
if (clearCheckIn !== pending) return;
|
|
if (event === "rename" || pending.generation !== generation || sessionFile !== ctx.sessionManager.getSessionFile()) { unconfirmed(); return; }
|
|
const branch = ctx.sessionManager.getBranch(), index = cursor === null ? -1 : branch.findIndex(entry => entry.id === cursor);
|
|
if (cursor !== null && index < 0) { unconfirmed(); return; }
|
|
for (const entry of branch.slice(index + 1)) if (entry.type === "custom_message") acceptScheduleList({ role: "custom", customType: entry.customType, details: entry.details }, ctx);
|
|
});
|
|
pending.watcher.on("error", unconfirmed);
|
|
pending.startDeadline = () => {
|
|
if (clearCheckIn !== pending || pending.deadline || agentRunActive) return;
|
|
if (pending.generation !== generation || sessionFile !== ctx.sessionManager.getSessionFile()) { unconfirmed(); return; }
|
|
pending.deadline = setTimeout(unconfirmed, 5_000); pending.deadline.unref();
|
|
};
|
|
// A passive result may wait for the busy turn's safe flush; do not expire it beforehand.
|
|
if (!agentRunActive) pending.startDeadline();
|
|
} catch { unconfirmed(); return false; }
|
|
pi.sendUserMessage(`/${list} all`, { expandPromptTemplates: true, deliverAs: "followUp" });
|
|
return true;
|
|
}
|
|
function acceptScheduleList(message: { role: string; customType?: string; details?: unknown }, ctx: ExtensionContext) {
|
|
if (message.role !== "custom" || message.customType !== "scheduled-task" || !clearCheckIn) return;
|
|
const details = message.details as { includeAll?: boolean; tasks?: CheckInTask[] } | undefined;
|
|
if (!details?.includeAll || !Array.isArray(details.tasks)) return;
|
|
const pending = clearCheckIn; cancelCheckInRemoval();
|
|
if (pending.generation !== generation || pending.sessionFile !== ctx.sessionManager.getSessionFile()) return;
|
|
const remove = schedulerCommand("schedule-remove");
|
|
if (!remove) { ctx.ui.notify(schedulerMessages.unavailable, "warning"); return; }
|
|
const matching = details.tasks.filter(task => task.name === `goals-${ctx.sessionManager.getSessionId()}`);
|
|
if (matching.some(task => !ownsCheckIn(task, ctx))) ctx.ui.notify(schedulerMessages.foreign, "warning");
|
|
for (const task of matching.filter(task => ownsCheckIn(task, ctx))) {
|
|
if (!/^[a-zA-Z0-9_-]+$/.test(task.id) || details.tasks.some(other => other !== task && other.id.startsWith(task.id))) { ctx.ui.notify(schedulerMessages.invalid, "warning"); continue; }
|
|
pi.sendUserMessage(`/${remove} ${task.id}`, { expandPromptTemplates: true, deliverAs: "followUp" });
|
|
}
|
|
}
|
|
const notedPlanValue = (prefix: string) => {
|
|
const snapshot = readPlan();
|
|
if (snapshot.text === undefined) return null;
|
|
const m = new RegExp(`^\\-\\s*${prefix}:\\s*(.+)$`, "im").exec(foldPlan(snapshot.text));
|
|
return m?.[1]?.trim() ?? null;
|
|
};
|
|
function refresh(ctx: ExtensionContext) {
|
|
if (state.child || state.mode === "chat") { ctx.ui.setStatus("goals", undefined); ctx.ui.setWidget("goals", undefined); return; }
|
|
const snapshot = readPlan();
|
|
if (snapshot.text === undefined) {
|
|
ctx.ui.setStatus("goals", snapshot.error);
|
|
ctx.ui.setWidget("goals", [snapshot.error]);
|
|
return;
|
|
}
|
|
const items = goals(snapshot.text);
|
|
const accepted = items.filter((g) => g.status === "done").length;
|
|
const stage = { planning: "📝 planning", supervising: "👀 supervising", paused: "⏸ paused", solo: "🛠 solo" }[state.mode];
|
|
ctx.ui.setStatus("goals", `${stage} ${accepted}/${items.length} goals`);
|
|
const mark = (status: GoalStatus) => status === "done" ? "✓" : status === "reported" ? "x" : status === "active" ? "◼" : status === "cancelled" ? "✗" : "◻";
|
|
const priority: Record<GoalStatus, number> = { active: 0, reported: 1, open: 2, done: 3, cancelled: 4 };
|
|
const sorted = [...items].sort((a, b) => priority[a.status] - priority[b.status]);
|
|
const visible = sorted.slice(0, WIDGET_GOAL_LIMIT);
|
|
const lines = visible.map((g) => `${mark(g.status)} G${items.indexOf(g) + 1}: ${g.subject}`);
|
|
const hidden = sorted.slice(WIDGET_GOAL_LIMIT);
|
|
let summary = "";
|
|
if (hidden.length) {
|
|
const counts = (["done", "reported", "active", "open", "cancelled"] as const).map(status => {
|
|
const count = hidden.filter(g => g.status === status).length;
|
|
return count ? `${count} ${mark(status)}` : "";
|
|
}).filter(Boolean);
|
|
summary = `… ${counts.join(", ")}; `;
|
|
}
|
|
const planPath = relative(ctx.cwd, state.plan!);
|
|
const external = isAbsolute(planPath) || planPath === ".." || planPath.startsWith(`..${sep}`);
|
|
lines.push(summary + (external ? `${basename(state.plan!)} (external)` : planPath));
|
|
if (ctx.mode === "tui") ctx.ui.setWidget("goals", () => ({
|
|
render: (width: number) => lines.map((line, index) => truncateToWidth(` ${line}`, width, external && index === lines.length - 1 ? "… (external)" : "…")),
|
|
invalidate() {},
|
|
}));
|
|
else ctx.ui.setWidget("goals", lines);
|
|
}
|
|
function watchPlan(ctx: ExtensionContext) {
|
|
pendingPlanNotice = undefined;
|
|
planWatcher?.close();
|
|
planWatcher = undefined;
|
|
clearTimeout(planEditTimer);
|
|
planEditTimer = undefined;
|
|
const snapshot = readPlan();
|
|
if (snapshot.text !== undefined) syncPlanHashes(snapshot.text);
|
|
if (state.child || state.mode !== "supervising" || !state.plan) return;
|
|
const stamp = generation;
|
|
// Atomic replacements are observable; task/evidence bookkeeping is recorded passively. — Pi/OpenAI
|
|
// Goal status or requirement changes wake the supervisor and request current plan context.
|
|
try {
|
|
planWatcher = watch(dirname(state.plan), { persistent: false }, () => {
|
|
if (stamp !== generation) return;
|
|
if (planEditTimer) clearTimeout(planEditTimer);
|
|
planEditTimer = setTimeout(() => {
|
|
planEditTimer = undefined;
|
|
if (stamp !== generation || state.mode !== "supervising") return;
|
|
const snapshot = readPlan();
|
|
if (snapshot.text === undefined) { ctx.ui.notify(snapshot.error!, "warning"); return; }
|
|
clearChangedFinalReview(snapshot.text);
|
|
refresh(ctx);
|
|
const views = planViews(snapshot.text);
|
|
const activityHash = digest(views.activity);
|
|
if (activityHash === planActivityHash) return;
|
|
planActivityHash = activityHash;
|
|
const hash = digest(views.notify);
|
|
if (hash === planHash) {
|
|
send(planActivityRecorded(state.plan!), false, true);
|
|
return;
|
|
}
|
|
planHash = hash;
|
|
notice = true;
|
|
fullPlanContextDue ||= requirements(snapshot.text) !== requirements(lastWorkingSet);
|
|
if (!pendingPlanNotice) { pendingPlanNotice = planChangedReview(state.plan!); send(pendingPlanNotice); }
|
|
}, 150);
|
|
});
|
|
planWatcher.on("error", (error) => { planWatcher?.close(); planWatcher = undefined; ctx.ui.notify(`Plan monitoring failed: ${error.message}`, "error"); });
|
|
} catch (error) { ctx.ui.notify(`Plan monitoring unavailable: ${String(error)}`, "error"); }
|
|
}
|
|
function restore(ctx: ExtensionContext) {
|
|
cancelCheckInRemoval(); agentRunActive = false;
|
|
notices.restore(ctx, [REVIEW]);
|
|
generation++;
|
|
state = initial();
|
|
for (const entry of ctx.sessionManager.getBranch()) {
|
|
if (entry.type === "custom" && entry.customType === STATE) state = structuredClone(entry.data as State);
|
|
}
|
|
delete (state as State & { signoffs?: unknown }).signoffs; // Retire old session metadata; never certify [x].
|
|
notice = true;
|
|
turnsStale = 0;
|
|
lastWorkingSet = "";
|
|
pendingUpkeep = undefined;
|
|
finalReviewTurnDigest = undefined;
|
|
preparedRole = undefined;
|
|
fullPlanContextDue = true;
|
|
refresh(ctx);
|
|
watchPlan(ctx);
|
|
}
|
|
function sendAttachment(plan: string, session: string, text: string) {
|
|
pi.sendMessage({ customType: "pi-goals-supervision", content: workerAttachment(plan, session, text), display: true }, { triggerTurn: false });
|
|
}
|
|
const roleKey = () => `${state.child ? "worker" : "parent"}:${state.mode}:${state.plan ?? ""}`;
|
|
function send(content: string, triggerTurn = true, collapse = false, prepareRole = false) {
|
|
// Custom messages map to the same user-role model input without an empty user bubble.
|
|
// Role changes still use a normal prompt because custom triggerTurn bypasses before_agent_start.
|
|
if (triggerTurn) {
|
|
const prompt = `[pi-goals]\n${content}`;
|
|
if (prepareRole || preparedRole !== roleKey()) {
|
|
notices.compact(prompt);
|
|
pi.sendUserMessage(prompt, { deliverAs: "followUp" });
|
|
} else notices.prompt(prompt);
|
|
} else if (collapse) notices.passive(content);
|
|
else pi.sendMessage({ customType: "pi-goals-supervision", content, display: true }, { deliverAs: "nextTurn" });
|
|
}
|
|
async function confirmOwnership(ctx: ExtensionContext, target: string, text: string): Promise<boolean> {
|
|
if (target !== state.plan || state.mode === "chat") { ctx.ui.notify(nativeMessages.externalOwnershipUnknown(target, state.worker), "warning"); return false; }
|
|
if (opening) { ctx.ui.notify("A worker launch/resume is still pending; inspect its result before takeover.", "warning"); return false; }
|
|
const stamp = generation;
|
|
const revision = workerRevision;
|
|
const confirmation = "Worker confirmed stopped";
|
|
const choice = await ctx.ui.select("Confirm all other writers for the current and target plans are stopped (inspect Intercom and their native panes). A missing handle is not proof. Take over in this session?", [confirmation, "Cancel"]);
|
|
if (stamp !== generation || revision !== workerRevision) return false;
|
|
if (choice !== confirmation) return false;
|
|
if (readFileSync(target, "utf8") !== text) { ctx.ui.notify("Plan changed during takeover; confirm again.", "warning"); return false; }
|
|
return true;
|
|
}
|
|
function enterSolo(ctx: ExtensionContext) {
|
|
state.mode = "solo"; state.workerStopped = true;
|
|
generation++; notice = true; fullPlanContextDue = true; save(); refresh(ctx); watchPlan(ctx);
|
|
send(`${removeGoalSchedule(ctx.sessionManager.getSessionId())}\n\n${soloNotice(state.plan!)}`);
|
|
}
|
|
const help = "/goals new [initial idea] | edit | discuss | review | ready | status | stop | resume | solo | attach <plan.md> [solo] | model <model> | quit (exit/clear)\nOpenGoalWorker opens a native project pane; use Intercom to steer the verified worker session. Stop pauses work. Quit/exit/clear preserves the plan and clears goal state without a model call; worker processes are unchanged. No forced compaction or model switch; the worker pane's own model is chosen with /model in that pane. Hourly check-ins are one session-bound schedule_task check-in; plan-change reviews are the plan-watcher event hook.";
|
|
async function ready(ctx: ExtensionContext, menu: boolean, edit = false) {
|
|
if (state.mode !== "planning") { ctx.ui.notify("Ready applies to a draft; use status or resume.", "warning"); return; }
|
|
const text = planText();
|
|
const items = goals(text);
|
|
if (!edit && (!items.length || items.some(g => !g.subject) || new Set(items.map((g) => key(g.subject))).size !== items.length)) {
|
|
ctx.ui.notify("Write a plan with distinct '- [ ] goal: ...' subjects before Ready.", "warning"); return;
|
|
}
|
|
const stamp = generation;
|
|
if (menu || edit) {
|
|
if (menu) pi.sendMessage({ customType: "goal-plan-proposal", content: text, display: true }, { triggerTurn: false });
|
|
const choice = edit ? "Edit" : await ctx.ui.select(`Review ${state.plan}`, ["Ready", "Discuss", "Edit", "Cancel"]);
|
|
if (stamp !== generation || digest(planText()) !== digest(text)) { ctx.ui.notify("Plan changed during review. Review it again.", "warning"); return; }
|
|
if (choice === "Discuss") { ctx.ui.notify(discuss, "info"); return; }
|
|
if (choice === "Edit") {
|
|
const edited = await ctx.ui.editor("Edit goal plan", text);
|
|
if (edited !== undefined && stamp === generation && planText() === text && state.plan) { writeFileSync(state.plan, edited); refresh(ctx); }
|
|
return;
|
|
}
|
|
if (choice !== "Ready") return;
|
|
}
|
|
state.mode = "supervising"; generation++; notice = true; fullPlanContextDue = true; save(); refresh(ctx); watchPlan(ctx);
|
|
send(`${checkIn(ctx)}\n\n${readyApproved(WORKER, state.plan!, state.worker?.sessionFile, text, ctx.sessionManager.getSessionId())}`);
|
|
}
|
|
|
|
function identity(ctx: ExtensionContext): Peer {
|
|
return { sessionId: ctx.sessionManager.getSessionId(), sessionFile: ctx.sessionManager.getSessionFile() ?? "",
|
|
paneId: process.env.HERDR_PANE_ID ?? "", model: ctx.model ? ctx.model.provider + "/" + ctx.model.id : undefined };
|
|
}
|
|
const records = <T,>(ctx: ExtensionContext, type: string): T[] => ctx.sessionManager.getBranch().flatMap(entry => entry.type === "custom" && entry.customType === type ? [entry.data as T] : []);
|
|
const pendingReports = (ctx: ExtensionContext) => {
|
|
const reports = records<Report>(ctx, REPORT), reviews = records<ReportReview>(ctx, REVIEW);
|
|
return reports.filter(report => !reviews.some(review => reviewedReportId(review) === report.id)
|
|
&& !reports.some(newer => newer.session === report.session && newer.supersedes === report.id));
|
|
};
|
|
const reportLabel = (report: Report) => {
|
|
const revision = report.id.split(":").at(-1)!.slice(0, 8);
|
|
const plainTask = report.task?.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/[*_`~<>]/g, "").trim().replace(/\s+/g, " ").slice(0, 100);
|
|
return `event ${revision}${plainTask ? ` — ${plainTask}` : ""} (eventId ${report.id})`;
|
|
};
|
|
function savedWorkerView(ctx: ExtensionContext, source: { runtimeId?: string; sessionFile?: string; task?: string }, runtime: Parameters<typeof buildWorkerView>[3] = {}, diagnostic = false) {
|
|
if (!source.sessionFile) return workerViewUnavailable(workerViewText.noHistory);
|
|
try {
|
|
const history = source.runtimeId === ctx.sessionManager.getSessionId() ? ctx.sessionManager : savedSession(source.sessionFile);
|
|
if (source.runtimeId && history.getSessionId() !== source.runtimeId) return workerViewUnavailable(workerViewText.identityMismatch);
|
|
const view = buildWorkerView(history.getBranch(), source.sessionFile, source.task ?? "", runtime, state.workerView, diagnostic);
|
|
state.workerView = view.cursor; save();
|
|
return view.text;
|
|
} catch (error) { return workerViewUnavailable(viewClip(String(error), 300)); }
|
|
}
|
|
function recordWorkerEvent(ctx: ExtensionContext, event: WorkerEvent, wake = true) {
|
|
if (records<Report>(ctx, REPORT).some(saved => saved.id === event.id) || records<WorkerEvent>(ctx, WORKER_EVENT).some(saved => saved.id === event.id)) return;
|
|
pi.appendEntry(WORKER_EVENT, event);
|
|
const needsDirectAttention = ATTENTION_EVENTS.has(event.kind) && wake;
|
|
send(workerStatus(event.plan, event.session, event.id, event.kind, event.text), needsDirectAttention, true);
|
|
}
|
|
function remindReports(ctx: ExtensionContext) {
|
|
if (state.child || state.mode !== "supervising") return;
|
|
const reports = pendingReports(ctx);
|
|
const reportIds = reports.map(report => report.id);
|
|
const branch = ctx.sessionManager.getBranch();
|
|
const sinceReminder = branch.slice(branch.map(entry => entry.type === "custom" ? entry.customType : "").lastIndexOf(REVIEW_REMINDER) + 1);
|
|
if (!sinceReminder.some(entry => entry.type === "custom" && entry.customType === REPORT && reportIds.includes((entry.data as Report).id))) return;
|
|
pi.appendEntry(REVIEW_REMINDER);
|
|
send(pendingReportReviews(reports.map(reportLabel)));
|
|
}
|
|
pi.registerEntryRenderer(REVIEW, (entry, { expanded }, theme) => {
|
|
const review = entry.data as ReportReview;
|
|
if (expanded) return new Markdown(review.content, 0, 0, getMarkdownTheme());
|
|
const revision = reviewedReportId(review)?.split(":").at(-1)?.slice(0, 8) ?? "unknown";
|
|
return {
|
|
render: (width) => [truncateToWidth(theme.fg("muted", `[pi-goals] Worker stop review: ${review.verdict} · event ${revision} · ${keyHint("app.tools.expand", "expand")}`), width)],
|
|
invalidate() {},
|
|
};
|
|
});
|
|
function registerChannel(ctx: ExtensionContext) {
|
|
liveContext = ctx;
|
|
const registration: IntercomExtensionRegistration = {
|
|
namespace: "pi-goals", ownerEligible: false,
|
|
onReady: value => { channel = value; },
|
|
onEvent: event => {
|
|
if (event.type === "session_left" && event.sessionId === state.worker?.intercomId && state.plan) {
|
|
const worker = state.worker;
|
|
worker.disconnectRevision = (worker.disconnectRevision ?? 0) + 1; save();
|
|
const episode = `disconnect-${worker.disconnectRevision}`;
|
|
let entryId = episode, text = nativeMessages.disconnected, kind: GoalEventKind = "unclassified";
|
|
try {
|
|
const branch = savedSession(worker.sessionFile!).getBranch();
|
|
const run = branch.filter(entry => entry.type === "custom" && entry.customType === RUN).at(-1);
|
|
const stop = branch.filter(entry => entry.type === "custom" && entry.customType === STOP).at(-1);
|
|
const stopped = stop?.type === "custom" ? stop.data as WorkerStop : undefined;
|
|
if (run && (!stopped || stopped.entryId !== run.id && !stopped.entryId.startsWith(`${run.id}:`))) { entryId = `${run.id}:${episode}`; kind = "blocker"; }
|
|
else if (stopped) {
|
|
entryId = `${stopped.entryId}:${episode}`;
|
|
text = `Worker disconnected after its recorded ${stopped.kind ?? "unclassified"} event ${stopped.entryId}.`;
|
|
kind = "receipt";
|
|
}
|
|
else {
|
|
const assistant = branch.filter(entry => entry.type === "message" && entry.message.role === "assistant").at(-1)?.id;
|
|
if (assistant) entryId = `${assistant}:${episode}`;
|
|
}
|
|
} catch { /* Unknown history remains visible without inventing completion or review debt. */ }
|
|
recordWorkerEvent(ctx, { id: `${event.sessionId}:${entryId}`, plan: state.plan, session: event.sessionId, sessionFile: worker.sessionFile || "", requestId: worker.requestId!, task: worker.task, text, kind });
|
|
}
|
|
if (event.type !== "message" || !event.payload || typeof event.payload !== "object") return;
|
|
const data = event.payload as { type?: string; to?: string; requestId?: string; plan?: string; sessionFile?: string; text?: string; identity?: Peer; entryId?: string; kind?: GoalEventKind; review?: ReportReview };
|
|
if (data.type === "attachment_rejected" && state.child && state.parent && event.fromSessionId === state.parent.intercomId && data.requestId === state.parent.requestId && data.plan === state.plan) {
|
|
const text = data.text || nativeMessages.attachmentRejected;
|
|
state.mode = "paused"; state.parent = undefined; generation++; notice = true; save(); refresh(ctx);
|
|
send(text, true, true);
|
|
return;
|
|
}
|
|
if (data.type === "review" && state.child && state.parent && event.fromSessionId === state.parent.intercomId && records<State>(ctx, STATE).some(saved => saved.child && saved.parent?.intercomId === event.fromSessionId && saved.parent.requestId === data.requestId && saved.plan === data.plan) && data.sessionFile === ctx.sessionManager.getSessionFile() && data.review) {
|
|
const prior = records<ReportReview>(ctx, REVIEW).find(saved => reviewedReportId(saved) === reviewedReportId(data.review!));
|
|
const review = prior || data.review;
|
|
if (!prior && review.verdict === "changes_requested" && (state.mode === "paused" || data.plan !== state.plan || data.requestId !== state.parent.requestId || !review.continuation.trim())) return;
|
|
if (!prior) {
|
|
pi.appendEntry(REVIEW, review);
|
|
if (review.verdict === "changes_requested") {
|
|
notices.compact(review.content);
|
|
pi.sendUserMessage(review.content, { deliverAs: "followUp" });
|
|
}
|
|
}
|
|
channel?.publish({ ...data, review, type: "review_saved", to: state.parent.intercomId }, { audience: "capable" });
|
|
return;
|
|
}
|
|
if (data.type === "review_saved" && !state.child && data.review) {
|
|
const draft = records<ReportReview>(ctx, REVIEW_DRAFT).find(review => review.id === data.review!.id);
|
|
const report = records<Report>(ctx, REPORT).find(report => report.id === (draft && reviewedReportId(draft)));
|
|
if (!draft || !report || event.fromSessionId !== report.session || data.requestId !== report.requestId || !records<State>(ctx, STATE).some(saved => saved.worker && saved.worker.parentId === data.to && saved.worker.requestId === report.requestId && saved.worker.intercomId === report.session) || data.plan !== report.plan) return;
|
|
try {
|
|
const saved = savedSession(report.sessionFile).getBranch().some(entry => {
|
|
if (entry.type !== "custom" || entry.customType !== REVIEW) return false;
|
|
const review = entry.data as ReportReview;
|
|
return review.id === draft.id && reviewedReportId(review) === report.id && review.verdict === draft.verdict
|
|
&& review.content === draft.content && review.continuation === draft.continuation;
|
|
});
|
|
if (saved && !records<ReportReview>(ctx, REVIEW).some(review => review.id === draft.id)) pi.appendEntry(REVIEW, draft);
|
|
} catch { ctx.ui.notify("Worker review delivery remains unverified; inspect its saved session and retry review_subagent.", "warning"); }
|
|
return;
|
|
}
|
|
const worker = state.worker;
|
|
if (data.type === "attached" && !state.child && worker?.parentId && data.to === worker.parentId && data.plan === state.plan
|
|
&& (!data.requestId || data.requestId !== worker.requestId || Boolean(worker.intercomId && worker.intercomId !== event.fromSessionId))) {
|
|
const text = nativeMessages.uncorrelatedAttachment(worker.requestId, data.requestId, worker.paneId || worker.identity?.paneId);
|
|
channel?.publish({ type: "attachment_rejected", to: event.fromSessionId, requestId: data.requestId, plan: data.plan, text }, { audience: "capable" });
|
|
send(workerStatus(data.plan || state.plan || "unknown", event.fromSessionId, `attachment:${data.requestId || "missing"}`, "unclassified", text), true, true);
|
|
return;
|
|
}
|
|
if (state.child || !worker || !state.plan || !worker.parentId || !data.requestId || data.to !== worker.parentId || event.fromSessionId === data.to || data.requestId !== worker.requestId || data.plan !== state.plan) return;
|
|
if (data.type === "attached" && typeof data.sessionFile === "string" && isAbsolute(data.sessionFile) && (!worker.intercomId || worker.intercomId === event.fromSessionId)) {
|
|
worker.intercomId = event.fromSessionId; worker.sessionFile = data.sessionFile;
|
|
if (data.identity) worker.identity = data.identity;
|
|
workerRevision++; save();
|
|
sendAttachment(state.plan, event.fromSessionId, nativeMessages.attached(data.sessionFile));
|
|
reconcileReports(ctx);
|
|
}
|
|
if (data.type === "stopped" && event.fromSessionId === worker.intercomId && typeof data.entryId === "string" && data.entryId && typeof data.text === "string") {
|
|
const id = `${event.fromSessionId}:${data.entryId}`;
|
|
if (records<Report>(ctx, REPORT).some(report => report.id === id) || records<WorkerEvent>(ctx, WORKER_EVENT).some(saved => saved.id === id)) return;
|
|
if (data.identity) { worker.identity = data.identity; worker.sessionFile = data.identity.sessionFile; save(); }
|
|
const report: Report = { id, plan: state.plan, session: event.fromSessionId, sessionFile: worker.sessionFile!, requestId: data.requestId, task: worker.task, text: data.text, kind: data.kind ?? "unclassified" };
|
|
recordWorkerEvent(ctx, report);
|
|
}
|
|
},
|
|
};
|
|
pi.events.emit(INTERCOM_EXTENSION_REGISTER_EVENT, registration);
|
|
}
|
|
function reconcileReports(ctx: ExtensionContext) {
|
|
if (state.child) return;
|
|
const owners = records<State>(ctx, STATE).filter(saved => saved.worker?.intercomId && saved.worker.sessionFile && saved.worker.requestId && saved.worker.parentId);
|
|
for (const owner of new Map(owners.map(saved => [saved.worker!.requestId, saved])).values()) {
|
|
const worker = owner.worker!;
|
|
try {
|
|
for (const entry of savedSession(worker.sessionFile!).getBranch()) {
|
|
if (entry.type !== "custom" || ![STOP, WORKER_EVENT].includes(entry.customType)) continue;
|
|
const stopped = entry.data as WorkerStop;
|
|
if (stopped.to !== worker.parentId || stopped.requestId !== worker.requestId || stopped.plan !== owner.plan) continue;
|
|
recordWorkerEvent(ctx, { id: `${worker.intercomId}:${stopped.entryId}`, plan: stopped.plan, session: worker.intercomId!, sessionFile: worker.sessionFile!, requestId: stopped.requestId, task: worker.task, text: stopped.text, kind: stopped.kind ?? "unclassified" }, false);
|
|
}
|
|
} catch { /* Unavailable saved history is not evidence of a stopped worker. */ }
|
|
}
|
|
if (ctx.isIdle()) remindReports(ctx);
|
|
}
|
|
const reportStop = (text: string, kind: GoalEventKind, automatic = false, suppressRoutineTurnEnd = false) => {
|
|
if (!state.child || !state.parent || !state.plan || !liveContext) return;
|
|
const branch = liveContext.sessionManager.getBranch();
|
|
const runId = branch.filter(entry => entry.type === "custom" && entry.customType === RUN).at(-1)?.id
|
|
|| branch.filter(entry => entry.type === "message" && entry.message.role === "assistant").at(-1)?.id;
|
|
if (!runId) return;
|
|
const inRun = (saved: WorkerStop) => saved.requestId === state.parent?.requestId && saved.plan === state.plan && (saved.entryId === runId || saved.entryId?.startsWith(`${runId}:`));
|
|
if (automatic && kind === "unclassified") {
|
|
const ended = records<WorkerStop>(liveContext, STOP).filter(inRun).at(-1);
|
|
if (ended) return ended;
|
|
const explicit = records<WorkerStop>(liveContext, WORKER_EVENT).filter(inRun).at(-1);
|
|
if (suppressRoutineTurnEnd && explicit && ["running", "waiting", "no_change", "decision"].includes(explicit.kind ?? "")) return explicit;
|
|
}
|
|
const type = automatic || POTENTIAL_STOP_EVENTS.has(kind) ? STOP : WORKER_EVENT;
|
|
const entryId = `${runId}:${digest(`${state.parent.requestId}:${state.plan}:${kind}:${text}`)}`;
|
|
let stopped = records<WorkerStop>(liveContext, type).find(saved => saved.entryId === entryId);
|
|
if (!stopped) {
|
|
stopped = { type: "stopped", to: state.parent.intercomId, requestId: state.parent.requestId, plan: state.plan, text: Buffer.from(text).subarray(0, 6000).toString("utf8"), entryId, identity: identity(liveContext), kind };
|
|
pi.appendEntry(type, stopped);
|
|
}
|
|
try {
|
|
if (!channel?.snapshot().connected) throw new Error("disconnected");
|
|
channel.publish(stopped, { audience: "capable" });
|
|
} catch { send(nativeMessages.reportUnavailable, false); }
|
|
return stopped;
|
|
};
|
|
pi.on("session_start", (_e, ctx) => {
|
|
restore(ctx); registerChannel(ctx); reconcileReports(ctx);
|
|
});
|
|
pi.on("session_tree", (_e, ctx) => restore(ctx));
|
|
pi.on("session_shutdown", () => { reportStop(nativeMessages.shuttingDown, "unclassified", true); cancelCheckInRemoval(); agentRunActive = false; pauseCheckIn = false; channel = undefined; liveContext = undefined; generation++; finalReviewTurnDigest = undefined; planWatcher?.close(); planWatcher = undefined; clearTimeout(planEditTimer); planEditTimer = undefined; });
|
|
// Only successful compaction needs resync; failed/cancelled attempts leave pending context alone.
|
|
// Defer to prompt preparation: same-run continuation retains Pi's current role/context.
|
|
pi.on("session_compact", () => { notice = true; fullPlanContextDue = true; preparedRole = undefined; });
|
|
pi.on("turn_end", (_event, ctx) => {
|
|
if (!["supervising", "solo"].includes(state.mode)) return;
|
|
const snapshot = readPlan();
|
|
if (snapshot.text === undefined) { notice = true; return; }
|
|
const workingSet = foldPlan(snapshot.text);
|
|
fullPlanContextDue ||= requirements(workingSet) !== requirements(lastWorkingSet);
|
|
turnsStale = workingSet === lastWorkingSet ? turnsStale + 1 : 0;
|
|
lastWorkingSet = workingSet;
|
|
refresh(ctx);
|
|
if (turnsStale === 8 && unfinishedGoals(snapshot.text)) {
|
|
// In Pi 0.85.1 triggerTurn:false updates saved history, not the live loop snapshot.
|
|
// Queue intent locally until ordinary prompt preparation, never force another turn.
|
|
pendingUpkeep = { generation, workingSet };
|
|
}
|
|
});
|
|
// Queued follow-ups can be consumed inside the same run, without before_agent_start.
|
|
pi.on("message_end", (event, ctx) => {
|
|
if (event.message.role === "custom" && event.message.customType === "intercom_message") reconcileReports(ctx);
|
|
if (event.message.role !== "user" && !(event.message.role === "custom" && event.message.customType === "pi-goals-prompt")) return;
|
|
const content = typeof event.message.content === "string" ? event.message.content : event.message.content.filter(part => part.type === "text").map(part => part.text).join("\n");
|
|
if (pendingPlanNotice && content === `[pi-goals]\n${pendingPlanNotice}`) pendingPlanNotice = undefined;
|
|
if (!state.finalReview || !["supervising", "solo"].includes(state.mode)) return;
|
|
const snapshot = readPlan();
|
|
if (snapshot.text === undefined || state.finalReview.planDigest !== digest(snapshot.text)) return;
|
|
if (content === `[pi-goals]\n${finalReview(state.plan!, snapshot.text)}`) finalReviewTurnDigest = state.finalReview.planDigest;
|
|
});
|
|
pi.on("agent_end", (event, ctx) => {
|
|
const last = event.messages.filter(message => message.role === "assistant").at(-1);
|
|
const text = last?.role === "assistant" ? last.errorMessage || last.content.filter(part => part.type === "text").map(part => part.text).join("\n") || last.stopReason : nativeMessages.noAssistant;
|
|
reportStop(text, last?.role === "assistant" && last.stopReason === "aborted" ? "aborted" : last?.role === "assistant" && (last.stopReason === "error" || last.errorMessage) ? "blocker" : "unclassified", true, true);
|
|
finalReviewTurnDigest = undefined; refresh(ctx); if (!planWatcher && state.mode === "supervising") watchPlan(ctx); });
|
|
pi.on("agent_start", (_event, ctx) => {
|
|
agentRunActive = true;
|
|
if (state.child && state.parent) pi.appendEntry(RUN, { plan: state.plan, parent: state.parent, session: identity(ctx) });
|
|
if (clearCheckIn) { clearTimeout(clearCheckIn.deadline); clearCheckIn.deadline = undefined; }
|
|
});
|
|
let requestedPlanReview: { generation: number; digest: string } | undefined;
|
|
pi.on("agent_settled", async (_e, ctx) => {
|
|
agentRunActive = false;
|
|
clearCheckIn?.startDeadline?.();
|
|
reconcileReports(ctx);
|
|
remindReports(ctx);
|
|
const requested = requestedPlanReview; requestedPlanReview = undefined;
|
|
if (!requested || requested.generation !== generation || state.child || state.mode !== "planning" || !ctx.hasUI) return;
|
|
const snapshot = readPlan();
|
|
if (snapshot.text === undefined || digest(snapshot.text) !== requested.digest) return;
|
|
await ready(ctx, true);
|
|
});
|
|
// No context hook. Historical message arrays, native checkpoints and model selection are untouched.
|
|
pi.on("before_agent_start", (event, ctx) => {
|
|
if (state.mode === "chat") return;
|
|
const snapshot = readPlan();
|
|
if (snapshot.text === undefined) {
|
|
notice = true; // Retry resync on the next turn; do not consume a failed snapshot.
|
|
return { systemPrompt: `${event.systemPrompt}\n\n${state.child ? childPlanRole : ""}\n${snapshot.error}` };
|
|
}
|
|
clearChangedFinalReview(snapshot.text);
|
|
const role = state.child ? childPlanRole + (state.mode === "paused" ? "\n" + pausedRole : "") : state.mode === "supervising"
|
|
? supervisor(WORKER, state.plan!, ctx.sessionManager.getSessionId())
|
|
: state.mode === "planning" ? planning(state.plan!) : state.mode === "paused" ? pausedRole : soloRole;
|
|
fullPlanContextDue ||= requirements(snapshot.text) !== requirements(lastWorkingSet);
|
|
const pendingFinalReview = ["supervising", "solo"].includes(state.mode) ? state.finalReview : undefined;
|
|
if (pendingFinalReview) finalReviewTurnDigest = pendingFinalReview.planDigest;
|
|
// Returned messages enter both Pi's prompt snapshot and saved history together.
|
|
// Unlike nextTurn, retaining intent here lets a fresh plan resync supersede upkeep,
|
|
// and drops obsolete reminders after edits, takeover, pause or session navigation.
|
|
const message = pendingFinalReview
|
|
? { customType: "pi-goals-final-review", content: finalReview(state.plan!, snapshot.text), display: false }
|
|
: notice || fullPlanContextDue
|
|
? { customType: "pi-goals-plan", content: planContext(state.child ? "worker" : state.mode, state.plan, fullPlanContextDue ? snapshot.text : unfinishedGoals(snapshot.text), fullPlanContextDue ? "full" : "short"), display: false }
|
|
: pendingUpkeep?.generation === generation && pendingUpkeep.workingSet === foldPlan(snapshot.text)
|
|
&& ["supervising", "solo"].includes(state.mode) && unfinishedGoals(snapshot.text)
|
|
? { customType: "pi-goals-upkeep", content: upkeep(state.plan!, unfinishedGoals(snapshot.text), state.mode === "supervising" ? ctx.sessionManager.getBranch().filter(entry => entry.type === "custom_message" && entry.customType === "pi-goals-upkeep").length : undefined), display: false } : undefined;
|
|
if (message) turnsStale = 0;
|
|
notice = false;
|
|
fullPlanContextDue = false;
|
|
lastWorkingSet = foldPlan(snapshot.text);
|
|
pendingUpkeep = undefined;
|
|
const pending = !state.child && state.mode === "supervising" ? pendingReports(ctx) : [];
|
|
preparedRole = roleKey();
|
|
return { systemPrompt: `${event.systemPrompt}\n\n${role}${pending.length ? `\n${pendingReportReviews(pending.map(reportLabel))}` : ""}`, ...(message ? { message } : {}) };
|
|
});
|
|
pi.on("input", (event, ctx) => {
|
|
if (event.source !== "extension") { pauseCheckIn = false; return; }
|
|
const wake = /^\[Scheduled task ([a-zA-Z0-9_-]+) fired\]\nName: ([^\n]+)\nAction: prompt\n/.exec(event.text);
|
|
if (!wake || wake[2] !== `goals-${ctx.sessionManager.getSessionId()}` || !ownedCheckInIds(ctx).has(wake[1])) return;
|
|
const snapshot = readPlan();
|
|
if (state.mode !== "supervising" || snapshot.text !== undefined && !unfinishedGoals(snapshot.text)) return { action: "handled" as const };
|
|
});
|
|
pi.on("tool_result", (event, ctx) => {
|
|
if (event.toolName !== "manage_scheduled_task" || event.isError) return;
|
|
const task = (event.details as { task?: CheckInTask } | undefined)?.task;
|
|
if (!task || !ownsCheckIn(task, ctx)) return;
|
|
if (pauseCheckIn && state.mode === "paused" && event.input.action === "disable" && task.disabledAt) {
|
|
state.pausedCheckIns = { ...state.pausedCheckIns, [task.id]: task.disabledAt }; pauseCheckIn = false; save();
|
|
} else if (["enable", "remove"].includes(String(event.input.action)) && state.pausedCheckIns?.[task.id]) {
|
|
delete state.pausedCheckIns[task.id]; save();
|
|
}
|
|
});
|
|
pi.on("tool_call", (event, ctx) => {
|
|
if (state.mode !== "chat" && event.toolName === "intercom" && event.input?.openProjectPaneIfMissing === true) return { block: true, reason: nativeMessages.workerCreationRequiresOpenGoalWorker };
|
|
if (state.mode !== "chat" && event.toolName === "subagent" && event.input?.action === "project.open") return { block: true, reason: nativeMessages.workerCreationRequiresOpenGoalWorker };
|
|
if (["schedule_task", "manage_scheduled_task"].includes(event.toolName)) {
|
|
const input = event.input as Record<string, unknown>;
|
|
const ids = ownedCheckInIds(ctx);
|
|
const ownedPrefix = typeof input.id === "string" && [...ids].some(id => id.startsWith(input.id as string));
|
|
if (ownedPrefix && !ids.has(input.id as string)) return { block: true, reason: schedulerMessages.invalid };
|
|
const owned = input.name === `goals-${ctx.sessionManager.getSessionId()}` || typeof input.id === "string" && ids.has(input.id);
|
|
if (event.toolName === "schedule_task" && owned && (state.child || state.mode !== "supervising" || !unfinishedGoals(planText()) || input.action !== "prompt" || input.type !== "interval" || input.scope !== "session")) return { block: true, reason: schedulerMessages.creation };
|
|
if (owned && typeof input.prompt === "string" && input.prompt !== input.prompt.trim().replace(/\s+/g, " ")) return { block: true, reason: schedulerMessages.format };
|
|
}
|
|
if (event.toolName !== "subagent" && event.toolName !== "OpenGoalWorker") return;
|
|
const action = event.input?.action;
|
|
// Stock owns helper contracts and capabilities. Inspection and cancellation stay available.
|
|
if (event.toolName === "subagent" && typeof action === "string" && ["list", "get", "models", "guide", "status", "children.list", "project.status", "stop", "interrupt"].includes(action)) return;
|
|
const nativeWorkerControl = event.toolName === "OpenGoalWorker" || typeof action === "string" && action.startsWith("project.");
|
|
if (["planning", "paused"].includes(state.mode)) return { block: true, reason: goalToolBlocked(state.mode) };
|
|
if (nativeWorkerControl && (state.child || state.mode === "solo")) return { block: true, reason: goalToolBlocked(state.child ? "worker" : state.mode) };
|
|
});
|
|
|
|
pi.registerTool({
|
|
name: "RequestPlanReview", label: "Present settled goal plan", description: requestPlanReviewDescription,
|
|
parameters: Type.Object({}),
|
|
async execute(_id, _params, _signal, _update, ctx) {
|
|
if (state.child || state.mode !== "planning" || !ctx.hasUI) return result(planReviewResult.unavailable);
|
|
requestedPlanReview = { generation, digest: digest(planText()) };
|
|
return result(planReviewResult.queued);
|
|
},
|
|
});
|
|
|
|
pi.registerCommand("goals", {
|
|
description: "Goal plan actions: new, edit, discuss, review, ready, status, stop, resume, solo, attach, model, quit (exit/clear)",
|
|
getArgumentCompletions: (prefix) => ["new", "attach", "edit", "discuss", "review", "ready", "status", "stop", "resume", "solo", "model", "help", "exit", "clear", "quit"].filter((verb) => verb.startsWith(prefix)).map((verb) => ({ value: verb, label: verb })),
|
|
handler: async (args, ctx) => {
|
|
try {
|
|
if (state.child) {
|
|
if (["stop", "resume"].includes(args.trim())) { cancelCheckInRemoval(); state.mode = args.trim() === "stop" ? "paused" : "solo"; generation++; save(); ctx.ui.notify(nativeMessages.workerPause(state.mode === "paused"), "info"); return; }
|
|
ctx.ui.notify("This is the delegated worker. Goal approval belongs to its parent.", "info"); return;
|
|
}
|
|
let command = args.trim();
|
|
if (!command) {
|
|
const actions = [
|
|
...({
|
|
chat: ["new — New plan…", "attach — Open plan…"],
|
|
planning: ["edit — Edit plan…", "discuss — Discuss changes to the plan", "ready — Approve draft"],
|
|
supervising: ["review — Check progress", "stop — Pause work"],
|
|
paused: ["resume — Resume work"],
|
|
solo: ["stop — Pause work"],
|
|
})[state.mode],
|
|
...(["planning", "supervising", "paused"].includes(state.mode) ? ["model — Settings: worker model"] : []),
|
|
"help — Show commands", "quit — Exit and clear goals",
|
|
];
|
|
const before = generation;
|
|
const choice = await ctx.ui.select("Goal plan actions", actions);
|
|
if (!choice || before !== generation) return;
|
|
command = choice.split(" — ")[0];
|
|
if (command === "new") {
|
|
const value = await ctx.ui.editor("Planning instructions (optional; blank uses this conversation)", "");
|
|
if (value === undefined || before !== generation) return;
|
|
command += ` ${value.trim()}`;
|
|
}
|
|
if (["attach", "model"].includes(command)) {
|
|
const value = await ctx.ui.editor(command === "attach" ? "Plan path (optional: solo)" : "Worker model (provider/model)", "");
|
|
if (!value?.trim() || before !== generation) return;
|
|
command += ` ${value.trim()}`;
|
|
}
|
|
}
|
|
if (command === "quit" || command === "clear") command = "exit";
|
|
if (command === "help") { ctx.ui.notify(help, "info"); return; }
|
|
if (command === "status") {
|
|
refresh(ctx);
|
|
ctx.ui.notify([
|
|
`Mode: ${state.mode}`,
|
|
`Plan: ${state.plan ?? "none"}`,
|
|
`Preferred worker model (plan, not configuration): ${notedPlanValue("preferred worker model") ?? "inherit"}`,
|
|
`Last observed worker model: ${state.worker?.identity?.model ?? "unconfirmed"}; verify current choice before claiming configuration.`,
|
|
`Selected worker-stop reviews pending delivery: ${pendingReports(ctx).map(reportLabel).join("; ") || "none"}`,
|
|
`Latest worker status event: ${records<WorkerEvent>(ctx, WORKER_EVENT).at(-1)?.kind ?? "none"}`,
|
|
`Recorded worker session: ${state.worker?.sessionFile ?? "not recorded"}`,
|
|
`Worker Intercom: ${state.worker?.intercomId ?? "unconfirmed"}; native pane: ${state.worker?.identity?.paneId || state.worker?.paneId || "unconfirmed"}`,
|
|
notedPlanValue("worker session") ? `Worker session noted in plan: ${notedPlanValue("worker session")}` : "",
|
|
`Check-in: session-scoped pi-scheduler task ${JSON.stringify(`goals-${ctx.sessionManager.getSessionId()}`)} (default 1h; /schedules all shows current recurrence; manage_scheduled_task updates it)`,
|
|
"Inspect the exact Intercom session and native pane; a binding or idle status is not completion.",
|
|
].filter(Boolean).join("\n"), "info");
|
|
return;
|
|
}
|
|
if (command === "discuss") {
|
|
if (state.mode !== "planning") { ctx.ui.notify("Discuss applies to a draft.", "warning"); return; }
|
|
ctx.ui.notify(discuss, "info"); return;
|
|
}
|
|
if (command === "review" && state.mode === "supervising") { send(manualReview(state.plan ?? "", unfinishedGoals(planText()))); return; }
|
|
if (command === "edit" || command === "review" || command === "ready") { await ready(ctx, command === "review", command === "edit"); return; }
|
|
if (command === "model" || command.startsWith("model ")) {
|
|
if (!state.plan || !goals(planText()).length) { ctx.ui.notify("Register a goal plan first.", "warning"); return; }
|
|
const ref = command.slice("model".length).trim();
|
|
if (!ref) { ctx.ui.notify("Use /goals model <provider/model>; no preference changed.", "info"); return; }
|
|
const lines = planText().split("\n");
|
|
const pref = `- preferred worker model: ${ref}`;
|
|
const found = lines.findIndex((line) => /^-\s*preferred worker model:/i.test(line));
|
|
if (found >= 0) lines[found] = pref;
|
|
else { const title = lines.findIndex((line) => /^#\s/.test(line)); lines.splice(title >= 0 ? title + 1 : 0, 0, pref); }
|
|
writeFileSync(state.plan, lines.join("\n"));
|
|
syncPlanHashes(planText());
|
|
refresh(ctx);
|
|
notice = true; fullPlanContextDue = true;
|
|
ctx.ui.notify(`Preferred worker model recorded as ${ref}; not yet configured. Pass it to the agent in its assignment or live steering for configuration through supported controls, then verify its actual model.`, "info");
|
|
return;
|
|
}
|
|
if (command === "attach" || command.startsWith("attach ")) {
|
|
const rest = command.slice("attach".length).trim();
|
|
const [raw, kind, extra] = rest.split(/\s+/);
|
|
const solo = kind === "solo";
|
|
if (extra || (kind && !solo)) { ctx.ui.notify("Use /goals attach <path-to-plan.md> [solo].", "warning"); return; }
|
|
if (!raw) { ctx.ui.notify("Use /goals attach <path-to-plan.md> [solo].", "info"); return; }
|
|
const target = isAbsolute(raw) ? raw : resolve(ctx.cwd, raw);
|
|
let text: string;
|
|
try { text = readFileSync(target, "utf8"); } catch { ctx.ui.notify(`Cannot read plan at ${target}.`, "error"); return; }
|
|
if (!goals(text).length || goals(text).some(g => !g.subject)) { ctx.ui.notify(`${target} has no '- [ ] goal:' lines with valid subjects; attach a judgeable plan.`, "warning"); return; }
|
|
if (!solo && state.plan === target && state.mode !== "chat") {
|
|
notice = true; fullPlanContextDue = true; refresh(ctx);
|
|
ctx.ui.notify(nativeMessages.samePlanRestored, "info"); return;
|
|
}
|
|
const noted = /^-\s*worker session:\s*(\S+)/im.exec(foldPlan(text))?.[1];
|
|
if (!(await confirmOwnership(ctx, target, text))) return;
|
|
if (noted && !state.worker) state.worker = { sessionFile: resolve(ctx.cwd, noted) };
|
|
enterSolo(ctx);
|
|
return;
|
|
}
|
|
if (command === "exit") {
|
|
cancelCheckInRemoval();
|
|
state = initial(); generation++; workerRevision++; pendingUpkeep = undefined; notice = true;
|
|
save(); refresh(ctx); watchPlan(ctx);
|
|
const queued = requestCheckInRemoval(ctx);
|
|
ctx.ui.notify(queued ? schedulerMessages.queued : schedulerMessages.cleared, queued ? "info" : "warning");
|
|
return;
|
|
}
|
|
if (command === "stop") {
|
|
if (state.mode === "planning") { ctx.ui.notify("A draft cannot pause; use /goals quit to clear goal state and preserve the draft.", "warning"); return; }
|
|
if (state.mode !== "solo" && state.mode !== "supervising") return;
|
|
cancelCheckInRemoval();
|
|
state.pausedFrom = state.mode;
|
|
state.mode = "paused"; generation++; notice = true; fullPlanContextDue = true; save(); refresh(ctx); watchPlan(ctx);
|
|
pauseCheckIn = true;
|
|
const pause = pauseExitNotice(state.worker, false);
|
|
const requestCleanup = Boolean(state.worker) || hasScheduleTool();
|
|
if (!requestCleanup) ctx.ui.notify(pause, "info"); // Visible now; passive model context waits for a prompt.
|
|
send(`${removeGoalSchedule(ctx.sessionManager.getSessionId(), true)}\n\n${pause}`, requestCleanup);
|
|
return;
|
|
}
|
|
if (command === "resume") {
|
|
if (state.mode !== "paused" || !state.plan) { ctx.ui.notify("Only a paused approved plan can resume. A draft needs Ready.", "warning"); return; }
|
|
if (state.pausedFrom === "solo") { enterSolo(ctx); return; }
|
|
state.mode = "supervising"; generation++; notice = true; fullPlanContextDue = true; save(); refresh(ctx); watchPlan(ctx);
|
|
send(`${checkIn(ctx)}\n\n${resumeNotice(WORKER, state.plan, state.worker)}`);
|
|
return;
|
|
}
|
|
if (command === "solo") {
|
|
if (!state.plan || !goals(planText()).length || goals(planText()).some(g => !g.subject)) { ctx.ui.notify("Register a goal plan first.", "warning"); return; }
|
|
if (!(await confirmOwnership(ctx, state.plan, planText()))) return;
|
|
enterSolo(ctx);
|
|
return;
|
|
}
|
|
if (command !== "new" && !command.startsWith("new ")) { ctx.ui.notify(`Unknown or incomplete command. ${help}`, "warning"); return; }
|
|
const objective = command.slice(4).trim();
|
|
if ((state.worker && !state.workerStopped) || state.mode === "supervising") { ctx.ui.notify("Exit and resolve the existing worker before replacing the plan. The current plan is preserved.", "warning"); return; }
|
|
const planDir = join(ctx.cwd, ".pi", "plan");
|
|
mkdirSync(planDir, { recursive: true });
|
|
const suffix = ctx.sessionManager.getSessionId().slice(-6);
|
|
const pattern = new RegExp(`^${suffix}-v(\\d+)\\.md$`);
|
|
let version = 1 + Math.max(0, ...readdirSync(planDir).map(name => Number(pattern.exec(name)?.[1] ?? 0)));
|
|
let path: string;
|
|
for (;;) {
|
|
path = join(planDir, `${suffix}-v${version}.md`);
|
|
try { writeFileSync(path, planDocument(objective), { flag: "wx" }); break; } catch (error) {
|
|
if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
|
|
version++;
|
|
}
|
|
}
|
|
state = { mode: "planning", plan: path, worker: state.worker, workerStopped: state.workerStopped }; generation++; notice = true; fullPlanContextDue = true; save(); refresh(ctx); watchPlan(ctx);
|
|
send(planningSeed(objective, path));
|
|
} catch (error) { ctx.ui.notify(String(error), "error"); }
|
|
},
|
|
});
|
|
pi.registerTool({
|
|
name: "worker_view", label: "Worker view", description: workerViewDescription,
|
|
parameters: Type.Object({ detail: Type.Optional(Type.String({ enum: ["summary", "diagnostic"] })) }),
|
|
renderResult(output, { expanded }) {
|
|
const body = output.content.filter(part => part.type === "text").map(part => part.text).join("\n");
|
|
return new Markdown(expanded ? body : `${body.split("\n").slice(0, 5).join("\n")}\n${keyHint("app.tools.expand", workerViewText.expand)}`, 0, 0, getMarkdownTheme());
|
|
},
|
|
async execute(_id, params, _signal, _update, ctx) {
|
|
const worker = state.worker, intercomId = worker?.intercomId, stamp = generation;
|
|
const source = state.child ? { runtimeId: ctx.sessionManager.getSessionId(), sessionFile: ctx.sessionManager.getSessionFile() }
|
|
: { runtimeId: worker?.identity?.sessionId, sessionFile: worker?.sessionFile, task: worker?.task };
|
|
const peers = channel?.snapshot().connected && channel.snapshot().supported ? await channel.listSessions().catch(() => undefined) : undefined;
|
|
const peer = state.child ? peers?.find(peer => peer.pid === process.pid) : peers?.find(peer => peer.id === intercomId);
|
|
const runtime: Parameters<typeof buildWorkerView>[3] = {
|
|
connected: peers ? Boolean(peer) : undefined,
|
|
status: peer?.status,
|
|
model: peer?.model,
|
|
contextPct: peer?.contextPct,
|
|
pid: peer?.pid,
|
|
};
|
|
if (peer?.pid) {
|
|
try { runtime.processes = descendantProcesses(peer.pid); }
|
|
catch (error) { runtime.processError = viewClip(String(error), 160); }
|
|
}
|
|
if (stamp !== generation || worker !== state.worker || intercomId !== state.worker?.intercomId || (!state.child && source.sessionFile !== state.worker?.sessionFile)) return result(messages.cancelled);
|
|
return result(savedWorkerView(ctx, source, runtime, params.detail === "diagnostic"));
|
|
},
|
|
});
|
|
pi.registerTool({
|
|
name: "OpenGoalWorker", label: "Open native goal worker", description: nativeMessages.openDescription,
|
|
parameters: Type.Object({ task: Type.String({ minLength: 1 }), model: Type.Optional(Type.String({ description: nativeMessages.modelDescription })) }),
|
|
async execute(_id, params, signal, _update, ctx) {
|
|
if (state.child || state.mode !== "supervising" || !state.plan) return result(goalToolBlocked(state.mode));
|
|
// TODO(2026-11+, Pi): Recheck pi-subagents/project-panes v1's one-pane-per-cwd limit before adding multiple visible workers.
|
|
if (opening) return result(nativeMessages.alreadyRecorded);
|
|
if (!params.task.trim()) return result(nativeMessages.taskRequired);
|
|
if (!channel?.snapshot().connected || !channel.snapshot().supported) return result(nativeMessages.intercomNotReady);
|
|
const preflight = generation;
|
|
const peers = await channel.listSessions().catch(() => undefined);
|
|
if (!peers) return result(nativeMessages.intercomNotReady);
|
|
const self = peers.filter(peer => peer.pid === process.pid);
|
|
if (self.length !== 1) return result(nativeMessages.noIdentity);
|
|
if (preflight !== generation || opening || signal?.aborted) return result(messages.cancelled);
|
|
const superseded = state.worker ? structuredClone(state.worker) : undefined;
|
|
const preference = params.model?.trim() || notedPlanValue("preferred worker model");
|
|
const model = preference && (preference.includes("/") || !/^(?:none|\(none|default|inherit|not stated)\b/i.test(preference)) ? preference : undefined;
|
|
const plan = state.plan;
|
|
if (opening || signal?.aborted) return result(messages.cancelled);
|
|
const requestId = randomUUID();
|
|
state.worker = { requestId, parentId: self[0].id, task: params.task }; state.workerStopped = false; workerRevision++; opening = true; save();
|
|
try {
|
|
// Stock open sends startup only to a newly created context; existing panes receive nothing.
|
|
const pane = await openProjectPane({ cwd: ctx.cwd, message: workerAssignment(plan, self[0].id, requestId, params.task, model), focus: false, signal });
|
|
if (pane.ok && state.plan === plan && state.worker?.requestId === requestId) {
|
|
if (pane.data.disposition === "already-open" && superseded) state.worker = superseded;
|
|
else {
|
|
if (superseded) pi.appendEntry(WORKER_RELEASE, { plan, worker: superseded, supersededBy: identity(ctx), task: params.task, at: new Date().toISOString() });
|
|
state.worker.paneId = pane.data.binding.paneId;
|
|
}
|
|
save(); refresh(ctx);
|
|
}
|
|
return result(pane.ok ? JSON.stringify({ disposition: pane.data.disposition, paneId: pane.data.binding.paneId, projectRoot: pane.data.binding.projectRoot, bindingPath: pane.data.bindingPath }) + nativeMessages.openReceipt : JSON.stringify(pane));
|
|
} catch (error) { return result(nativeMessages.openFailed + String(error)); }
|
|
finally { opening = false; }
|
|
},
|
|
});
|
|
pi.registerTool({
|
|
name: "AttachGoalPlan", label: "Attach delegated plan", description: attachGoalPlanDescription,
|
|
parameters: Type.Object({ path: Type.String(), parent: Type.Optional(Type.String()), requestId: Type.Optional(Type.String()) }),
|
|
async execute(_id, params, signal, _update, ctx) {
|
|
if (!state.child && (state.mode !== "chat" || !params.parent || !params.requestId)) return result(messages.childAttachOnly);
|
|
const authorize = !state.child || state.plan && state.plan !== params.path || params.parent !== undefined || params.requestId !== undefined;
|
|
if (state.child && authorize && (!state.parent || params.parent !== state.parent.intercomId || !params.requestId?.trim())) return result(nativeMessages.reattachAuthorization);
|
|
let text: string;
|
|
try {
|
|
if (!isAbsolute(params.path)) return result(messages.invalidAttachment);
|
|
text = readFileSync(params.path, "utf8");
|
|
const items = goals(text);
|
|
if (!items.length || items.some(g => !g.subject)) return result(messages.invalidAttachment);
|
|
} catch { return result(messages.invalidAttachment); }
|
|
if (authorize) {
|
|
if (!channel?.snapshot().connected || !channel.snapshot().supported) return result(nativeMessages.intercomNotReady);
|
|
const stamp = generation;
|
|
const peers = await channel.listSessions().catch(() => undefined);
|
|
if (!peers || !channel?.snapshot().connected || !channel.snapshot().supported) return result(nativeMessages.intercomNotReady);
|
|
if (stamp !== generation || signal?.aborted) return result(messages.cancelled);
|
|
if (!peers.some(peer => peer.id === params.parent && peer.pid !== process.pid)) return result(nativeMessages.parentUnavailable);
|
|
try { if (readFileSync(params.path, "utf8") !== text) return result(messages.invalidAttachment); } catch { return result(messages.invalidAttachment); }
|
|
if (!state.child) {
|
|
state = { ...initial(), child: true, mode: "solo" };
|
|
// First attachment can occur after agent_start in an ordinary chat.
|
|
if (agentRunActive) pi.appendEntry(RUN, { plan: params.path, parent: { intercomId: params.parent, requestId: params.requestId }, session: identity(ctx) });
|
|
}
|
|
state.parent = { intercomId: params.parent!, requestId: params.requestId! };
|
|
}
|
|
state.plan = params.path; generation++; notice = true; fullPlanContextDue = true; save(); refresh(ctx);
|
|
if (state.parent) channel?.publish({ type: "attached", to: state.parent.intercomId, requestId: state.parent.requestId, plan: state.plan, sessionFile: ctx.sessionManager.getSessionFile(), identity: identity(ctx) }, { audience: "capable" });
|
|
return result(childPlanAttached(params.path));
|
|
},
|
|
});
|
|
pi.registerTool({
|
|
name: "ReportGoalEvent", label: "Report delegated worker event", description: reportGoalEventDescription,
|
|
parameters: Type.Object({
|
|
kind: Type.String({ enum: ["review_request", "decision", "blocker", "completion", "progress", "running", "waiting", "receipt", "no_change"] }),
|
|
summary: Type.String({ minLength: 1 }),
|
|
}),
|
|
async execute(_id, params) {
|
|
if (!state.child || !state.parent || !state.plan || !liveContext) throw new Error("Only an attached delegated worker can report a goal event.");
|
|
const kind = params.kind as GoalEventKind;
|
|
if (!params.summary.trim()) throw new Error("Supply the canonical event summary and exact artifact paths when applicable.");
|
|
const stopped = reportStop(params.summary.trim(), kind);
|
|
if (!stopped) throw new Error("No active worker run is available for this event.");
|
|
return result(POTENTIAL_STOP_EVENTS.has(kind) ? "Recorded one visible stop request for supervisor judgment; no formal review was created." : "Recorded one visible status event without formal review.");
|
|
},
|
|
});
|
|
const sourceQuote = Type.Object({ path: Type.String({ minLength: 1 }), entryId: Type.Optional(Type.String()), quote: Type.String({ minLength: 1 }) });
|
|
pi.registerTool({
|
|
name: "review_subagent", label: "Review potential worker stop", description: reportReviewDescription,
|
|
parameters: Type.Object({
|
|
eventId: Type.String({ minLength: 1 }), goal: sourceQuote,
|
|
evidence: Type.Array(Type.Object({ path: Type.String({ minLength: 1 }), entryId: Type.Optional(Type.String()), quote: Type.Optional(Type.String()), observation: Type.String({ minLength: 1 }) }), { minItems: 1 }),
|
|
observation: Type.String({ minLength: 1 }), unmet: Type.String({ minLength: 1 }),
|
|
verdict: Type.String({ enum: ["accepted", "changes_requested", "blocked"] }), continuation: Type.Optional(Type.String()),
|
|
}),
|
|
async execute(_id, params, signal, _update, ctx) {
|
|
if (state.child || state.mode !== "supervising") throw new Error("Only the active parent supervisor can review a potential worker stop.");
|
|
const selected = records<Report>(ctx, REPORT).find(report => report.id === params.eventId);
|
|
const event = records<WorkerEvent>(ctx, WORKER_EVENT).find(event => event.id === params.eventId && POTENTIAL_STOP_EVENTS.has(event.kind));
|
|
const report = selected ?? event;
|
|
if (!report) throw new Error("Unknown owned potential-stop event ID; use the exact Event shown in the worker status.");
|
|
if (!["accepted", "changes_requested", "blocked"].includes(params.verdict) || !params.goal.quote.trim() || !params.observation.trim() || !params.unmet.trim() || params.verdict === "changes_requested" && !params.continuation?.trim()) throw new Error("Supply the verdict, inspection, unmet requirements (or none), and a concrete continuation for changes_requested.");
|
|
const sources = [params.goal, ...params.evidence].map(source => {
|
|
const gitEvidence = /^git:([0-9a-f]{7,64}):(.+)$/i.exec(source.path);
|
|
let path = source.path, bytes: Buffer, text: string;
|
|
if (gitEvidence) {
|
|
const [, commit, gitPath] = gitEvidence;
|
|
if (source.entryId || !gitPath.split("/").every(part => part && part !== "." && part !== "..")) throw new Error(`Invalid Git evidence: ${source.path}`);
|
|
try { bytes = Buffer.from(execFileSync("git", ["show", `${commit}:${gitPath}`], { cwd: ctx.cwd, encoding: "buffer" })); }
|
|
catch { throw new Error(`Unavailable Git evidence: ${source.path}`); }
|
|
text = bytes.toString("utf8");
|
|
} else {
|
|
path = resolve(ctx.cwd, source.path); bytes = readFileSync(path); text = bytes.toString("utf8");
|
|
if (source.entryId) {
|
|
const entry = savedSession(path).getBranch().find(entry => entry.id === source.entryId);
|
|
if (!entry) throw new Error(`Missing session entry: ${path}#${source.entryId}`);
|
|
const content = entry.type === "message" && "content" in entry.message ? entry.message.content : entry.type === "custom_message" ? entry.content : undefined;
|
|
text = typeof content === "string" ? content : Array.isArray(content) ? content.filter(part => part.type === "text").map(part => part.text).join("\n") : JSON.stringify(entry);
|
|
}
|
|
}
|
|
if (!bytes.length) throw new Error(`Empty evidence: ${path}`);
|
|
const binary = bytes.includes(0) || /\.(png|jpe?g|gif|webp|pdf|mp4)$/i.test(path);
|
|
if (!source.quote?.trim() && !binary || source.quote && !text.includes(source.quote)) throw new Error(`Quote does not match source: ${path}`);
|
|
if ("observation" in source && !source.observation.trim()) throw new Error(`Describe the inspected evidence: ${path}`);
|
|
return `${path}${source.entryId ? `#${source.entryId}` : ""}\n${source.quote ? `> ${source.quote}` : "[non-text capture]"}${"observation" in source ? `\nObserved: ${source.observation}` : ""}`;
|
|
});
|
|
const content = reportReviewContent(report.id, report.sessionFile, sources, params.observation, params.unmet, params.verdict, params.continuation || "");
|
|
const review: ReportReview = { id: digest(content), reportId: report.id, report: report.id, verdict: params.verdict, content, continuation: params.continuation || "" };
|
|
const payload = { type: "review", to: report.session, sessionFile: report.sessionFile, requestId: report.requestId, plan: report.plan, review };
|
|
if (Buffer.byteLength(JSON.stringify(payload)) > 16000) throw new Error("Review exceeds Intercom's 16 KiB limit; shorten the quotes and retain source references.");
|
|
if (records<ReportReview>(ctx, REVIEW).some(saved => reviewedReportId(saved) === report.id)) return result("This worker stop already has a delivered review; a later stop is a new event.");
|
|
if (!selected) pi.appendEntry(REPORT, report);
|
|
if (!channel?.snapshot().connected || !channel.snapshot().supported || signal?.aborted) throw new Error("Review delivery unavailable; the selected stop remains pending.");
|
|
if (!records<ReportReview>(ctx, REVIEW_DRAFT).some(saved => saved.id === review.id)) pi.appendEntry(REVIEW_DRAFT, review);
|
|
channel.publish(payload, { audience: "capable" });
|
|
return result("Review sent for saving in the worker conversation. Obligation remains pending until the exact saved review is verified; use /goals status to inspect delivery.");
|
|
},
|
|
});
|
|
pi.registerTool({
|
|
name: "CompleteGoal", label: "Review goal evidence",
|
|
description: completeGoalDescription,
|
|
parameters: Type.Object({ goal: Type.String({ minLength: 1 }), evidence: Type.Array(Type.String(), { minItems: 1 }), observation: Type.String({ minLength: 1 }) }),
|
|
async execute(_id, params, signal, _update, ctx) {
|
|
if (state.child || !state.plan || !["supervising", "solo"].includes(state.mode)) return result(messages.completionUnavailable);
|
|
const path = state.plan;
|
|
const stamp = generation;
|
|
return withFileMutationQueue(path, async () => {
|
|
if (stamp !== generation || path !== state.plan || state.child || !["supervising", "solo"].includes(state.mode)) return result(messages.completionUnavailable);
|
|
if (signal?.aborted) return result(messages.cancelled);
|
|
if (!params.goal.trim()) return result(messages.uniqueGoal);
|
|
const snapshot = readPlan();
|
|
if (snapshot.text === undefined) return result(snapshot.error!);
|
|
const text = snapshot.text;
|
|
const matches = goals(text).filter((g) => g.status !== "cancelled" && key(g.subject) === key(params.goal));
|
|
if (matches.length !== 1 || !state.plan) return result(messages.uniqueGoal);
|
|
const evidence = params.evidence.map((file) => isAbsolute(file) ? file : resolve(ctx.cwd, file));
|
|
try { for (const file of evidence) if (!readFileSync(file).length) throw new Error(emptyEvidence(file)); }
|
|
catch (error) { return result(evidenceUnavailable(error)); }
|
|
const subject = key(matches[0].subject);
|
|
const othersAccepted = goals(text).every((goal) => goal.status === "cancelled" || key(goal.subject) === subject || goal.status === "done");
|
|
if (othersAccepted && matches[0].status !== "done") {
|
|
if (clearChangedFinalReview(text)) return result(finalReviewInvalidated);
|
|
if (finalReviewTurnDigest !== digest(text)) {
|
|
if (!state.finalReview) {
|
|
state.finalReview = { planDigest: digest(text) };
|
|
save();
|
|
send(finalReview(path, text), true, false, true);
|
|
}
|
|
return result(finalReviewQueued(matches[0].subject));
|
|
}
|
|
}
|
|
const lines = text.split("\n");
|
|
lines[matches[0].index] = lines[matches[0].index].replace(/\[[ xX/✓-]\]/, "[✓]");
|
|
let log = lines.findIndex(line => FOLD_LINE.test(line));
|
|
if (log === -1) { lines.push("", "## Log"); log = lines.length - 1; }
|
|
lines.splice(log + 1, 0, "", completionLog(params.goal, params.observation, evidence, state.mode === "solo"));
|
|
writeFileSync(path, `${lines.join("\n").trimEnd()}\n`);
|
|
state.finalReview = undefined;
|
|
finalReviewTurnDigest = undefined;
|
|
syncPlanHashes(planText());
|
|
save(); refresh(ctx);
|
|
const remaining = Boolean(unfinishedGoals(planText()));
|
|
if (!remaining) requestCheckInRemoval(ctx);
|
|
return result(completionResult(matches[0].subject, ctx.sessionManager.getSessionId(), remaining, state.mode === "solo"));
|
|
});
|
|
},
|
|
});
|
|
}
|