@goah/cli 0.13.0 → 0.13.2

package/dist/pi-worker.js

@@ -0,0 +1,671 @@
+import { createRequire as __goahCreateRequire } from "node:module";
+const require = __goahCreateRequire(import.meta.url);
+import {
+  Agent
+} from "./chunk-XALZLRYK.js";
+import {
+  runProcessWorker
+} from "./chunk-7E7V6OIU.js";
+import {
+  createPiModel,
+  fauxAssistantMessage,
+  fauxText,
+  fauxToolCall,
+  typebox_exports
+} from "./chunk-6M3OOCKO.js";
+import "./chunk-K26BVR6O.js";
+import "./chunk-IIJQ3DW4.js";
+import "./chunk-2ZP2NBW3.js";
+import "./chunk-MPXK7QBL.js";
+import "./chunk-2QBQZGXF.js";
+import "./chunk-4KA63VNZ.js";
+import "./chunk-KAO7WIXG.js";
+import {
+  TRANSCRIPT_FORMAT_VERSION
+} from "./chunk-R6I3VKME.js";
+import {
+  normalizeAssistantText
+} from "./chunk-TJON22J4.js";
+import "./chunk-XPQKM3L7.js";
+
+// node_modules/goah-runner-pi/dist/pi-worker.js
+import { spawn } from "node:child_process";
+import { existsSync, mkdtempSync, readdirSync, readFileSync, realpathSync, rmSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { delimiter, dirname, join, resolve, sep } from "node:path";
+import { homedir, tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+function compactMessages(messages, maxRecent = 8) {
+  if (messages.length <= maxRecent + 1)
+    return messages;
+  const removed = messages.slice(1, -maxRecent);
+  const summary = removed.map((message, index) => `${index + 1}. ${messageText(message).slice(0, 240)}`).join("\n");
+  return [
+    messages[0],
+    { role: "user", content: `Compacted model view. Original trace is unchanged. Source message indexes 1-${removed.length}:
+${summary}`, timestamp: Date.now() },
+    ...messages.slice(-maxRecent)
+  ];
+}
+async function runPiWorker() {
+  await runProcessWorker(async (request, emit, rpc, controls) => {
+    const contextRecord = typeof request.context === "object" && request.context !== null && !Array.isArray(request.context) ? request.context : {};
+    const legacyRequest = request.turn === void 0;
+    const binding = request.turn?.goalCommitment;
+    const goalState = { bound: legacyRequest || binding !== null && binding !== void 0, ...binding ? { binding } : {} };
+    const profile = contextRecord.runnerProfile && typeof contextRecord.runnerProfile === "object" && !Array.isArray(contextRecord.runnerProfile) ? contextRecord.runnerProfile : {};
+    const runnerConfig = profile.config && typeof profile.config === "object" && !Array.isArray(profile.config) ? profile.config : {};
+    const provider = typeof runnerConfig.provider === "string" ? runnerConfig.provider : process.env.GOAH_PI_PROVIDER ?? "anthropic";
+    const modelId = typeof runnerConfig.model === "string" ? runnerConfig.model : process.env.GOAH_PI_MODEL;
+    if (!modelId)
+      throw new Error("GOAH_PI_MODEL is required");
+    const configured = createPiModel(provider, modelId);
+    const { models } = configured;
+    const privateAuth = request.runtime && typeof request.runtime === "object" && !Array.isArray(request.runtime) ? request.runtime : {};
+    const protectedPaths = Array.isArray(privateAuth.protectedPaths) ? privateAuth.protectedPaths.filter((value) => typeof value === "string").map((path) => resolve(path)) : [];
+    const model = typeof privateAuth.baseUrl === "string" ? { ...configured.model, baseUrl: privateAuth.baseUrl } : configured.model;
+    if (provider === "faux") {
+      const faux = configured.faux;
+      if (process.env.GOAH_PI_FAUX_ERROR) {
+        faux.setResponses([fauxAssistantMessage([], { stopReason: "error", errorMessage: process.env.GOAH_PI_FAUX_ERROR })]);
+      } else if (goalState.bound && !legacyRequest) {
+        const handoff = JSON.parse(process.env.GOAH_PI_FAUX_HANDOFF ?? "{}");
+        const current = contextRecord.workRecord && typeof contextRecord.workRecord === "object" && !Array.isArray(contextRecord.workRecord) ? contextRecord.workRecord : {};
+        const evidence = Array.isArray(contextRecord.sourceSeqs) ? contextRecord.sourceSeqs.filter((value) => typeof value === "number") : [];
+        const outcome = ["progress", "waiting", "blocked", "completion_proposed"].includes(String(handoff.outcome)) ? String(handoff.outcome) : "progress";
+        const handoffEvidence = Array.isArray(handoff.evidence) && handoff.evidence.every((value) => typeof value === "number") ? handoff.evidence : evidence.length ? [Math.max(...evidence)] : [];
+        const record = `# Current State
+
+Faux Goal outcome: ${outcome}.
+
+# Observations
+
+See the cited Ledger evidence.
+
+# Work Completed
+
+Executed the scripted faux Goal turn.
+
+# Decisions
+
+Record the scripted result from ${request.execution.id}.
+
+# Blockers
+
+${outcome === "blocked" ? "Blocked." : "None."}
+
+# Next Steps
+
+Follow the current Goal and explicit tools.
+`;
+        const finalResponse = fauxAssistantMessage([fauxText(String(handoff.message ?? `Goal work recorded with outcome ${outcome}.`)), fauxToolCall("handoff", { outcome, evidence: handoffEvidence })], { stopReason: "toolUse" });
+        const recordResponse = fauxAssistantMessage(fauxToolCall("work_record_update", { expectedRevision: Number(current.recordRevision ?? 0), content: record, reason: "record faux Goal progress", evidence: evidence.length ? [Math.max(...evidence)] : [] }), { stopReason: "toolUse" });
+        const fatalBatch = fauxAssistantMessage([fauxText("Stale completion attempt."), fauxToolCall("handoff", { outcome, evidence: handoffEvidence }), fauxToolCall("write", { path: "fatal.txt", content: "must not be written" })], { stopReason: "toolUse" });
+        faux.setResponses(process.env.GOAH_PI_FAUX_FATAL_BATCH === "1" ? [fatalBatch] : process.env.GOAH_PI_FAUX_HANDOFF_REPAIR === "1" ? [fauxAssistantMessage([fauxText("Premature completion attempt."), fauxToolCall("handoff", { outcome, evidence: handoffEvidence })], { stopReason: "toolUse" }), recordResponse, finalResponse] : [recordResponse, finalResponse]);
+      } else if (!goalState.bound) {
+        faux.setResponses([fauxAssistantMessage([fauxText(process.env.GOAH_PI_FAUX_RESPONSE ?? "Hello from Goah.")])]);
+      } else {
+        const handoff = JSON.parse(process.env.GOAH_PI_FAUX_HANDOFF ?? "{}");
+        const { message, ...handoffData } = handoff;
+        faux.setResponses([fauxAssistantMessage([fauxText(String(message ?? "Goal work recorded.")), fauxToolCall("handoff", handoffData)], { stopReason: "toolUse" })]);
+      }
+    }
+    let output = null;
+    let acceptedHandoff = null;
+    let revokedReason = "";
+    let response = "";
+    let responseFailure = "";
+    let compactions = 0;
+    let messageCounter = 0;
+    const messageIds = /* @__PURE__ */ new WeakMap();
+    const emittedUsers = /* @__PURE__ */ new Set();
+    const idFor = (message) => {
+      if (typeof message !== "object" || message === null)
+        return `message:${++messageCounter}`;
+      const existing = messageIds.get(message);
+      if (existing)
+        return existing;
+      const id = `message:${++messageCounter}`;
+      messageIds.set(message, id);
+      return id;
+    };
+    const root = resolve(process.cwd());
+    const capabilities = Array.isArray(contextRecord.capabilities) ? new Set(contextRecord.capabilities.filter((value) => typeof value === "string")) : void 0;
+    if (contextRecord.workRecord && typeof contextRecord.workRecord === "object" && !Array.isArray(contextRecord.workRecord) && typeof contextRecord.workRecord.recordRevision === "number")
+      goalState.recordRevision = contextRecord.workRecord.recordRevision;
+    const tools = createTools(root, (value) => {
+      if (!acceptedHandoff || !sameHandoff(acceptedHandoff.handoff, value))
+        throw new Error("Handoff tool executed without accepted validation");
+      output = { validationAttemptId: acceptedHandoff.attemptId, validationToken: acceptedHandoff.token, handoff: value };
+    }, rpc, capabilities, goalState, protectedPaths);
+    const contextPolicy = resolveContextPolicy(model.contextWindow, process.env);
+    emit({ type: "transcript.started", data: { formatVersion: TRANSCRIPT_FORMAT_VERSION, provider, model: modelId, runner: "pi", contextWindowTokens: model.contextWindow, maxOutputTokensPerTurn: model.maxTokens } });
+    const suppliedPrompt = typeof contextRecord.systemPrompt === "string" ? contextRecord.systemPrompt : void 0;
+    const activeContext = typeof contextRecord.text === "string" ? contextRecord.text : JSON.stringify(request.context);
+    const sourceSeqs = Array.isArray(contextRecord.sourceSeqs) ? contextRecord.sourceSeqs.filter((value) => Number.isInteger(value)) : [];
+    const basePrompt = process.env.GOAH_PI_SYSTEM_PROMPT ?? suppliedPrompt ?? (request.turn?.trigger.kind === "user_message" ? "You are Goah's primary Agent. Respond naturally to the Human." : `You are Goah Agent ${request.agent}. Inspect the supplied context and respond appropriately.`);
+    const systemPrompt = goalState.bound ? `${basePrompt}
+This Turn has a Goal commitment. You must update its Work Record, write a concise human-readable assistant message describing what happened, and call handoff exactly once with only machine-readable outcome and evidence. The message and Handoff are separate outputs. Treat the supplied context as authoritative.` : request.turn?.trigger.kind === "user_message" ? `${basePrompt}
+The active Goal, when supplied, is context rather than an assignment. Finish with an ordinary response unless a Goal tool establishes a commitment during this Turn. After commitment, update that Goal's Work Record, write a concise human-readable assistant message, and call handoff exactly once with separate machine-readable outcome and evidence. Treat the supplied context as authoritative.` : `${basePrompt}
+This Turn has no Goal commitment. Finish with an ordinary response and do not call handoff. Treat the supplied context as authoritative.`;
+    const agent = new Agent({
+      initialState: {
+        systemPrompt,
+        model,
+        thinkingLevel: typeof runnerConfig.thinking === "string" ? runnerConfig.thinking : "off",
+        tools
+      },
+      streamFn: async (requestModel, context, options) => {
+        emit({
+          type: "request.prepared",
+          data: {
+            provider: requestModel.provider,
+            model: requestModel.id,
+            systemPrompt: context.systemPrompt ?? "",
+            activeContext,
+            messages: JSON.parse(JSON.stringify(context.messages)),
+            tools: (context.tools ?? []).map((tool) => ({ name: tool.name, description: tool.description, parameters: tool.parameters })),
+            modelConfig: snapshotModelConfig(options),
+            sourceSeqs
+          }
+        });
+        const runtimeProvider = models.getProvider(requestModel.provider);
+        if (!runtimeProvider)
+          throw new Error(`Provider not found: ${requestModel.provider}`);
+        const runtimeModel = typeof privateAuth.baseUrl === "string" ? { ...requestModel, baseUrl: privateAuth.baseUrl } : requestModel;
+        return runtimeProvider.streamSimple(runtimeModel, context, { ...options, ...typeof privateAuth.apiKey === "string" ? { apiKey: privateAuth.apiKey } : {}, ...privateAuth.headers && typeof privateAuth.headers === "object" && !Array.isArray(privateAuth.headers) ? { headers: privateAuth.headers } : {}, ...process.env.GOAH_PI_CACHE_RETENTION === "none" ? { cacheRetention: "none" } : {} });
+      },
+      getApiKey: () => typeof privateAuth.apiKey === "string" ? privateAuth.apiKey : void 0,
+      transformContext: async (messages) => {
+        let view = messages;
+        if (estimateMessages(messages) >= contextPolicy.compactAtTokens) {
+          compactions += 1;
+          view = compactMessagesToTokenBudget(messages, contextPolicy.retainAfterCompactTokens);
+          const retained = new Set(view.filter((message) => messages.includes(message)));
+          const summary = view.find((message) => !messages.includes(message));
+          if (summary)
+            emit({ type: "context.compacted", data: { compaction: compactions, sourceMessageCount: messages.length, replacedMessageIds: messages.filter((message) => !retained.has(message)).map(idFor), retainedMessageIds: messages.filter((message) => retained.has(message)).map(idFor), summaryMessageId: idFor(summary), summary: messageText(summary) } });
+        }
+        return view;
+      },
+      beforeToolCall: async ({ assistantMessage, toolCall, args }) => {
+        if (revokedReason)
+          return { block: true, reason: `Turn authority was revoked: ${revokedReason}`, terminate: true };
+        if (toolCall.name !== "handoff")
+          return;
+        acceptedHandoff = null;
+        output = null;
+        const handoff = args;
+        try {
+          const result = await rpc("goal.handoff.validate", { handoff, candidateMessage: assistantResponseText(assistantMessage) });
+          if (result.accepted) {
+            acceptedHandoff = { attemptId: result.attemptId, token: result.token, handoff };
+            return;
+          }
+          const reason = result.issues.map((issue) => `- ${issue.message}`).join("\n");
+          if (result.fatal)
+            revokedReason = reason;
+          return { block: true, reason: `Handoff was not accepted:
+${reason}`, terminate: result.fatal };
+        } catch (error) {
+          revokedReason = error instanceof Error ? error.message : String(error);
+          return { block: true, reason: `Handoff validation could not continue: ${revokedReason}`, terminate: true };
+        }
+      },
+      shouldStopAfterTurn: () => output !== null || Boolean(revokedReason),
+      toolExecution: "sequential"
+    });
+    let acceptingSteering = true;
+    controls.onSteer((message) => {
+      if (!acceptingSteering)
+        return false;
+      agent.steer({ role: "user", content: message, timestamp: Date.now() });
+      return true;
+    });
+    agent.subscribe((event) => {
+      if (event.type === "turn_start")
+        emit({ type: "turn.started", data: {} });
+      else if (event.type === "message_start" && event.message.role === "user") {
+        const id = idFor(event.message);
+        if (!emittedUsers.has(id)) {
+          emittedUsers.add(id);
+          emit({ type: "message.user", data: { message: transcriptMessage(event.message, id) } });
+        }
+      } else if (event.type === "message_update") {
+        emit({ type: "message.assistant.delta", data: { messageId: idFor(event.message), delta: JSON.parse(JSON.stringify(event.assistantMessageEvent)) } });
+      } else if (event.type === "message_end" && event.message.role === "assistant") {
+        response = assistantResponseText(event.message);
+        if ((event.message.stopReason === "error" || event.message.stopReason === "aborted") && event.message.errorMessage)
+          responseFailure = event.message.errorMessage;
+        const handoffIntent = hasAgentToolCall(event.message, "handoff");
+        emit({ type: "message.assistant.completed", data: { message: transcriptMessage(event.message, idFor(event.message)), commitState: handoffIntent ? "provisional" : "committed" } });
+      } else if (event.type === "tool_execution_start")
+        emit({ type: "tool.called", data: { callId: event.toolCallId, name: event.toolName, arguments: JSON.parse(JSON.stringify(event.args)) } });
+      else if (event.type === "tool_execution_end")
+        emit({ type: "tool.completed", data: { callId: event.toolCallId, messageId: `tool:${event.toolCallId}`, name: event.toolName, result: JSON.parse(JSON.stringify(event.result)), isError: event.isError } });
+      else if (event.type === "turn_end")
+        emit({ type: "turn.completed", data: {} });
+    });
+    const abortAgent = () => agent.abort();
+    process.once("SIGTERM", abortAgent);
+    process.once("SIGINT", abortAgent);
+    try {
+      await agent.prompt(`Turn started at: ${request.execution.startedAt}
+
+${activeContext}
+
+Runner root: ${root}. Manage local files directly when the goal requires them.`);
+    } finally {
+      acceptingSteering = false;
+      process.off("SIGTERM", abortAgent);
+      process.off("SIGINT", abortAgent);
+    }
+    if (revokedReason)
+      return { outcome: "abnormal", reason: revokedReason };
+    if (!goalState.bound)
+      return response ? { outcome: "completed", response: { content: response } } : { outcome: "abnormal", reason: responseFailure || "Pi worker exited without a response" };
+    if (responseFailure)
+      return { outcome: "abnormal", reason: responseFailure };
+    if (!output)
+      return { outcome: "abnormal", reason: "Pi worker exited without an accepted Handoff" };
+    return { outcome: "completed", response: { content: response }, handoff: output };
+  });
+}
+function snapshotModelConfig(options) {
+  if (!options || typeof options !== "object" || Array.isArray(options))
+    return {};
+  const record = options;
+  const allowed = ["transport", "toolExecution", "temperature", "topP", "maxTokens", "reasoning", "thinkingLevel", "toolChoice"];
+  return Object.fromEntries(allowed.flatMap((key) => isJson(record[key]) ? [[key, JSON.parse(JSON.stringify(record[key]))]] : []));
+}
+function isJson(value) {
+  if (value === null || ["string", "number", "boolean"].includes(typeof value))
+    return true;
+  if (Array.isArray(value))
+    return value.every(isJson);
+  return Boolean(value && typeof value === "object" && Object.values(value).every(isJson));
+}
+function transcriptMessage(message, id) {
+  const value = JSON.parse(JSON.stringify(message));
+  const role = message.role === "assistant" ? "assistant" : message.role === "user" ? "user" : "tool";
+  return { id, role, content: value.content ?? value, ...value.usage !== void 0 ? { usage: value.usage } : {}, ...typeof value.stopReason === "string" ? { stopReason: value.stopReason } : {}, ...typeof value.errorMessage === "string" ? { errorMessage: value.errorMessage } : {} };
+}
+function createTools(root, handoff, rpc, capabilities, goalState, protectedPaths = []) {
+  const handoffTool = {
+    name: "handoff",
+    label: "Handoff",
+    description: "Record a structured handoff and end a Turn with a Goal commitment.",
+    parameters: typebox_exports.Object({
+      outcome: typebox_exports.Union([typebox_exports.Literal("progress"), typebox_exports.Literal("waiting"), typebox_exports.Literal("blocked"), typebox_exports.Literal("completion_proposed")]),
+      evidence: typebox_exports.Array(typebox_exports.Number())
+    }),
+    execute: async (_id, params) => {
+      const input = params;
+      const value = { outcome: input.outcome, evidence: input.evidence };
+      handoff(value);
+      return { content: [{ type: "text", text: "handoff recorded" }], details: value, terminate: true };
+    }
+  };
+  const rpcTools = createRpcTools(rpc, capabilities, (method, result) => {
+    if ((method === "goal.create" || method === "goal.work" || method === "goal.resume") && result && typeof result === "object" && !Array.isArray(result) && result.goalCommitment && typeof result.goalCommitment === "object" && !Array.isArray(result.goalCommitment)) {
+      const binding = result.goalCommitment;
+      if (typeof binding.goalId === "string" && typeof binding.goalRevision === "number") {
+        goalState.bound = true;
+        goalState.binding = { goalId: binding.goalId, goalRevision: binding.goalRevision };
+      }
+    }
+    if (method === "work_record.update" && result && typeof result === "object" && !Array.isArray(result) && typeof result.recordRevision === "number")
+      goalState.recordRevision = result.recordRevision;
+  });
+  const readTool = {
+    name: "read",
+    label: "Read",
+    description: "Read a UTF-8 file inside the current working directory.",
+    parameters: typebox_exports.Object({ path: typebox_exports.String() }),
+    execute: async (_id, params) => {
+      const input = params;
+      return { content: [{ type: "text", text: await readFile(scopedRunnerPath(root, input.path, protectedPaths), "utf8") }], details: {} };
+    }
+  };
+  const writeTool = {
+    name: "write",
+    label: "Write",
+    description: "Create or replace a UTF-8 file inside the current working directory.",
+    parameters: typebox_exports.Object({ path: typebox_exports.String(), content: typebox_exports.String() }),
+    execute: async (_id, params) => {
+      const input = params;
+      const path = scopedRunnerPath(root, input.path, protectedPaths);
+      await mkdir(dirname(path), { recursive: true });
+      await writeFile(path, input.content);
+      return { content: [{ type: "text", text: "written" }], details: {} };
+    }
+  };
+  const editTool = {
+    name: "edit",
+    label: "Edit",
+    description: "Replace one exact text occurrence in a UTF-8 file inside the current working directory.",
+    parameters: typebox_exports.Object({ path: typebox_exports.String(), oldText: typebox_exports.String(), newText: typebox_exports.String() }),
+    execute: async (_id, params) => {
+      const input = params;
+      const path = scopedRunnerPath(root, input.path, protectedPaths);
+      const source = await readFile(path, "utf8");
+      const first = source.indexOf(input.oldText);
+      if (first < 0)
+        throw new Error("edit oldText was not found");
+      if (source.indexOf(input.oldText, first + input.oldText.length) >= 0)
+        throw new Error("edit oldText is not unique");
+      await writeFile(path, `${source.slice(0, first)}${input.newText}${source.slice(first + input.oldText.length)}`);
+      return { content: [{ type: "text", text: "edited" }], details: { path: input.path } };
+    }
+  };
+  const bashTool = {
+    name: "bash",
+    label: "Bash",
+    description: "Run a sandboxed shell command inside the local runner root. Goah credential/control state is masked. If protected state shares the root, use the write tool to create new top-level paths. The command's process group is killed after timeout.",
+    parameters: typebox_exports.Object({ command: typebox_exports.String(), timeoutMs: typebox_exports.Optional(typebox_exports.Number()) }),
+    executionMode: "sequential",
+    execute: async (_id, params, signal) => runBashCommand(root, params, signal, protectedPaths)
+  };
+  return [readTool, writeTool, editTool, bashTool, ...rpcTools, handoffTool];
+}
+var BASH_TIMEOUT_HARD_CAP_MS = 6e5;
+function bashTimeoutMs(requested, env = process.env) {
+  const fallback = integerSetting(env.GOAH_PI_BASH_TIMEOUT_MS, 12e4);
+  const value = requested ?? fallback;
+  return Number.isFinite(value) && value > 0 ? Math.min(value, BASH_TIMEOUT_HARD_CAP_MS) : fallback;
+}
+async function runBashCommand(root, input, signal, protectedPaths = []) {
+  const timeoutMs = bashTimeoutMs(input.timeoutMs);
+  const sandboxTemp = mkdtempSync(join(tmpdir(), "goah-bash-"));
+  const launch = sandboxedShell(input.command, root, protectedPaths, sandboxTemp);
+  if (!launch) {
+    if (sandboxTemp)
+      rmSync(sandboxTemp, { recursive: true, force: true });
+    return { content: [{ type: "text", text: "Bash is unavailable because this platform cannot isolate Goah credential and control state." }], details: { command: input.command }, isError: true };
+  }
+  const child = spawn(launch.command, launch.args, { cwd: root, env: toolEnvironment(sandboxTemp), detached: process.platform !== "win32", stdio: ["ignore", "pipe", "pipe"] });
+  let stdout = "";
+  let stderr = "";
+  let timedOut = false;
+  let outputOverflow = false;
+  const killGroup = () => {
+    if (child.pid) {
+      try {
+        process.kill(process.platform === "win32" ? child.pid : -child.pid, "SIGKILL");
+      } catch {
+      }
+    }
+  };
+  const appendOutput = (channel, chunk) => {
+    if (outputOverflow)
+      return;
+    const text = chunk.toString();
+    const remaining = Math.max(0, 1e6 - stdout.length - stderr.length);
+    if (channel === "stdout")
+      stdout += text.slice(0, remaining);
+    else
+      stderr += text.slice(0, remaining);
+    if (text.length > remaining) {
+      outputOverflow = true;
+      killGroup();
+    }
+  };
+  child.stdout?.on("data", (chunk) => appendOutput("stdout", chunk));
+  child.stderr?.on("data", (chunk) => appendOutput("stderr", chunk));
+  const timer = setTimeout(() => {
+    timedOut = true;
+    killGroup();
+  }, timeoutMs);
+  const onAbort = () => killGroup();
+  signal?.addEventListener("abort", onAbort, { once: true });
+  const close = new Promise((resolve2, reject) => {
+    child.once("error", reject);
+    child.once("close", (code, signalName) => resolve2({ code, signal: signalName }));
+  });
+  try {
+    const result = await close;
+    if (timedOut)
+      return { content: [{ type: "text", text: `Command timed out after ${timeoutMs}ms and its process group was killed. Declare a larger timeoutMs for long-running commands.` }], details: { command: input.command, timedOutAfterMs: timeoutMs }, isError: true };
+    if (signal?.aborted)
+      return { content: [{ type: "text", text: "Command aborted with the wake." }], details: { command: input.command }, isError: true };
+    killGroup();
+    const failed = outputOverflow || result.code !== 0 || result.signal !== null;
+    return { content: [{ type: "text", text: `${stdout}${stderr}`.slice(-5e4) }], details: { command: input.command, exitCode: result.code, signal: result.signal, ...outputOverflow ? { outputOverflow: true } : {} }, ...failed ? { isError: true } : {} };
+  } finally {
+    clearTimeout(timer);
+    signal?.removeEventListener("abort", onAbort);
+    if (sandboxTemp)
+      rmSync(sandboxTemp, { recursive: true, force: true });
+  }
+}
+function resolveContextPolicy(contextWindowTokens, env) {
+  if (!Number.isInteger(contextWindowTokens) || contextWindowTokens <= 0)
+    throw new Error("model context window is missing");
+  const compactAtTokens = integerSetting(env.GOAH_PI_COMPACT_AT_TOKENS, Math.floor(contextWindowTokens * 0.7));
+  const retainAfterCompactTokens = integerSetting(env.GOAH_PI_RETAIN_CONTEXT_TOKENS, Math.floor(contextWindowTokens * 0.2));
+  if (retainAfterCompactTokens >= compactAtTokens || compactAtTokens >= contextWindowTokens)
+    throw new Error("invalid Pi context policy");
+  return { compactAtTokens, retainAfterCompactTokens };
+}
+function compactMessagesToTokenBudget(messages, retainTokens) {
+  if (messages.length <= 2 || estimateMessages(messages) <= retainTokens)
+    return messages;
+  const tailBudget = Math.max(1, Math.floor(retainTokens * 0.6));
+  let start = messages.length;
+  let retained = 0;
+  while (start > 1) {
+    const tokens = estimateMessages([messages[start - 1]]);
+    if (retained > 0 && retained + tokens > tailBudget)
+      break;
+    retained += tokens;
+    start -= 1;
+  }
+  const removed = messages.slice(1, start);
+  const rawSummary = removed.map((message, index) => `${index + 1}. ${messageText(message).slice(0, 240)}`).join("\n");
+  const summaryChars = Math.max(0, (retainTokens - retained - 80) * 4);
+  const summary = summaryChars === 0 ? "[older entries truncated]" : rawSummary.length <= summaryChars ? rawSummary : `[older entries truncated]
+${rawSummary.slice(-summaryChars)}`;
+  return [
+    messages[0],
+    { role: "user", content: `Compacted model view. Original trace is unchanged. Source message indexes 1-${removed.length}:
+${summary}`, timestamp: Date.now() },
+    ...messages.slice(start)
+  ];
+}
+function createRpcTools(rpc, allowed, onResult) {
+  const tool = (name, description, method, parameters) => ({
+    name,
+    label: name,
+    description,
+    parameters,
+    execute: async (_id, params) => {
+      const result = await rpc(method, params);
+      onResult?.(method, result);
+      return { content: [{ type: "text", text: JSON.stringify(result) }], details: result };
+    }
+  });
+  const definitions = [
+    ["ledger.search", tool("ledger_search", "Search durable ledger facts.", "ledger.search", typebox_exports.Object({ query: typebox_exports.String(), limit: typebox_exports.Optional(typebox_exports.Number()) }))],
+    ["memory.append", tool("memory_append", "Append a durable working-memory note that is injected into your future wakes. Record procedural knowledge, active hypotheses, and abandoned approaches with the reason; keep notes concise.", "memory.append", typebox_exports.Object({ note: typebox_exports.String() }))],
+    ["mail.send", tool("send_mail", "Send durable Mail to another Goal owner. goalId is required and routes the Mail into that owner's next committed Turn. Human communication must use request_human.", "mail.send", typebox_exports.Object({ to: typebox_exports.String(), goalId: typebox_exports.String(), level: typebox_exports.Union([typebox_exports.Literal("fyi"), typebox_exports.Literal("decision"), typebox_exports.Literal("emergency")]), body: typebox_exports.Any() }))],
+    ["schedule.set", tool("schedule_wake", "Schedule this agent's next wake.", "schedule.set", typebox_exports.Object({ at: typebox_exports.String(), reason: typebox_exports.String() }))],
+    ["team.list", tool("team_list", "Read the ledger-derived team roster and liveness state.", "team.list", typebox_exports.Object({}))],
+    ["goal.get", tool("get_goal", "Read the active Goal visible to this Turn. Visibility does not establish a Goal commitment.", "goal.get", typebox_exports.Object({}))],
+    ["goal.create", tool("create_goal", "Create a Root Goal from durable Human intent and bind this Turn. Do not use for greetings, questions, or routine single-turn work.", "goal.create", typebox_exports.Object({ objective: typebox_exports.String(), id: typebox_exports.Optional(typebox_exports.String()) }))],
+    ["goal.work", tool("work_on_goal", "Commit this direct CEO Turn to an existing active Root Goal owned by this Agent.", "goal.work", typebox_exports.Object({ goalId: typebox_exports.String() }))],
+    ["goal.delegate", tool("delegate_goal", "Atomically create a Child Goal with observation and verification methods, its Work Record, decision brief, and initial Wake.", "goal.delegate", typebox_exports.Object({ id: typebox_exports.String(), parentGoalId: typebox_exports.String(), expectedParentRevision: typebox_exports.Number(), childGoal: typebox_exports.Object({ id: typebox_exports.String(), objective: typebox_exports.String(), observationMethod: typebox_exports.String(), verificationMethod: typebox_exports.String(), owner: typebox_exports.String() }), brief: typebox_exports.Any(), reason: typebox_exports.String(), evidence: typebox_exports.Array(typebox_exports.Number()) }))],
+    ["goal.reassign", tool("reassign_goal", "Atomically transfer a child goal, notify both owners, and queue the new owner.", "goal.reassign", typebox_exports.Object({ id: typebox_exports.String(), goalId: typebox_exports.String(), expectedGoalRevision: typebox_exports.Number(), newOwner: typebox_exports.String(), brief: typebox_exports.Any(), reason: typebox_exports.String(), evidence: typebox_exports.Array(typebox_exports.Number()) }))],
+    ["goal.revise", tool("revise_goal", "Revise a Child Goal objective, observation method, and verification method as one new revision.", "goal.revise", typebox_exports.Object({ goalId: typebox_exports.String(), objective: typebox_exports.String(), observationMethod: typebox_exports.String(), verificationMethod: typebox_exports.String(), reason: typebox_exports.String(), evidence: typebox_exports.Array(typebox_exports.Number()) }))],
+    ["goal.pause", tool("pause_goal", "Pause a child goal and suppress queued motion.", "goal.pause", typebox_exports.Object({ goalId: typebox_exports.String() }))],
+    ["goal.resume", tool("resume_goal", "Resume a Goal. A direct Human Root resume binds the current Turn; Child Goal resume requires an already bound parent Turn.", "goal.resume", typebox_exports.Object({ goalId: typebox_exports.String() }))],
+    ["goal.complete", tool("complete_goal", "Complete a child goal with evidence produced under its current observation method. Root completion remains human authority.", "goal.complete", typebox_exports.Object({ goalId: typebox_exports.String(), revision: typebox_exports.Number(), reason: typebox_exports.String(), evidence: typebox_exports.Array(typebox_exports.Number()) }))],
+    ["human.request", tool("request_human", "Ask the human for a decision, observation-method confirmation, or root completion with evidence.", "human.request", typebox_exports.Object({ type: typebox_exports.Union([typebox_exports.Literal("decision"), typebox_exports.Literal("observation_method_confirmation"), typebox_exports.Literal("completion_recommendation")]), message: typebox_exports.Any(), evidence: typebox_exports.Array(typebox_exports.Number()) }))],
+    ["work_record.list", tool("work_record_list", "List the current Work Record for every Goal in the organization.", "work_record.list", typebox_exports.Object({}))],
+    ["work_record.read", tool("work_record_read", "Read one current Goal Work Record. Omit goalId to use the committed or visible Goal.", "work_record.read", typebox_exports.Object({ goalId: typebox_exports.Optional(typebox_exports.String()) }))],
+    ["work_record.history", tool("work_record_history", "Read the version timeline for a Goal Work Record.", "work_record.history", typebox_exports.Object({ goalId: typebox_exports.Optional(typebox_exports.String()) }))],
+    ["work_record.diff", tool("work_record_diff", "Compare two revisions of a Goal Work Record.", "work_record.diff", typebox_exports.Object({ goalId: typebox_exports.Optional(typebox_exports.String()), fromRevision: typebox_exports.Number(), toRevision: typebox_exports.Number() }))],
+    ["work_record.search", tool("work_record_search", "Search every Goal Work Record.", "work_record.search", typebox_exports.Object({ query: typebox_exports.String(), limit: typebox_exports.Optional(typebox_exports.Number()) }))],
+    ["work_record.update", tool("work_record_update", "Create the next version of the Work Record committed to this Turn with Ledger evidence.", "work_record.update", typebox_exports.Object({ expectedRevision: typebox_exports.Number(), content: typebox_exports.String(), reason: typebox_exports.String(), evidence: typebox_exports.Array(typebox_exports.Number()) }))],
+    ["goal.put", tool("put_goal", "Create or update a Goal through the authoritative goal.changed protocol using parent-layer authority.", "goal.put", typebox_exports.Object({ goal: typebox_exports.Any(), reason: typebox_exports.String(), evidence: typebox_exports.Array(typebox_exports.Number()) }))]
+  ];
+  return definitions.filter(([capability]) => !allowed || allowed.has(capability)).map(([, value]) => value);
+}
+function scopedRunnerPath(root, path, protectedPaths = []) {
+  const resolved = canonicalPath(resolve(root, path));
+  const canonicalRoot = canonicalPath(root);
+  if (resolved !== canonicalRoot && !resolved.startsWith(`${canonicalRoot}${sep}`))
+    throw new Error("path escapes runner root");
+  if (protectedPaths.map(canonicalPath).some((privatePath) => resolved === privatePath || resolved.startsWith(`${privatePath}${sep}`)))
+    throw new Error("path is protected Goah state");
+  return resolved;
+}
+function sandboxedShell(command, root, protectedPaths, sandboxTemp) {
+  if (process.platform === "darwin" && existsSync("/usr/bin/sandbox-exec")) {
+    const workspacePaths = sandboxWorkspacePaths(canonicalPath(root), protectedPaths.map(canonicalPath));
+    const workspaceAncestors = pathAncestors(canonicalPath(root));
+    const toolchains = toolchainReadPaths(canonicalPath(root));
+    const readableAncestors = toolchains.flatMap(pathAncestors);
+    const readable = ["/System", "/usr", "/bin", "/sbin", "/Library", "/etc", "/dev", "/private/etc", "/private/var/select", "/Applications", ...toolchains, ...workspacePaths, ...sandboxTemp ? [sandboxTemp] : []].filter(existsSync).map(canonicalPath);
+    const writable = [...workspacePaths, ...sandboxTemp ? [sandboxTemp] : [], "/dev"].map(canonicalPath);
+    const rules = ["(version 1)", "(deny default)", '(import "system.sb")', "(allow process*)", "(allow signal)", "(allow network*)", "(allow sysctl-read)", "(allow mach-lookup)", ...[.../* @__PURE__ */ new Set([...workspaceAncestors, ...readableAncestors])].map((path) => `(allow file-read* (literal ${JSON.stringify(path)}))`), ...readable.map((path) => `(allow file-read* (subpath ${JSON.stringify(path)}))`), ...writable.map((path) => `(allow file-write* (subpath ${JSON.stringify(path)}))`), ...protectedPaths.map(canonicalPath).map((path) => `(deny file-read* file-write* (subpath ${JSON.stringify(path)}))`)];
+    return { command: "/usr/bin/sandbox-exec", args: ["-p", rules.join(" "), "/bin/sh", "-lc", command] };
+  }
+  if (process.platform === "linux") {
+    const bwrap = ["/usr/bin/bwrap", "/bin/bwrap"].find(existsSync);
+    if (bwrap) {
+      const canonicalRoot = canonicalPath(root);
+      if (["/usr", "/bin", "/sbin", "/lib", "/lib64", "/etc"].some((path) => canonicalRoot === path || canonicalRoot.startsWith(`${path}${sep}`)))
+        return null;
+      return { command: bwrap, args: linuxSandboxArgs(command, canonicalRoot, protectedPaths, sandboxTemp) };
+    }
+  }
+  return null;
+}
+function linuxSandboxArgs(command, root, protectedPaths, sandboxTemp) {
+  const canonicalRoot = canonicalPath(root);
+  const workspacePaths = sandboxWorkspacePaths(canonicalRoot, protectedPaths.map(canonicalPath));
+  const systemPaths = ["/usr", "/bin", "/sbin", "/lib", "/lib64", "/etc"].filter(existsSync).flatMap((path) => ["--ro-bind", path, path]);
+  const mounted = ["/tmp", "/usr", "/bin", "/sbin", "/lib", "/lib64", "/etc"];
+  const toolchains = toolchainReadPaths(canonicalRoot).filter((path) => !mounted.some((base) => path === base || path.startsWith(`${base}${sep}`)) && path !== canonicalRoot && !path.startsWith(`${canonicalRoot}${sep}`));
+  const destinations = [canonicalRoot, ...toolchains].flatMap((path) => pathAncestors(path).slice(1)).filter((path) => !mounted.some((base) => path === base || path.startsWith(`${base}${sep}`)));
+  const directories = [...new Set(destinations)].sort((left, right) => left.length - right.length).flatMap((path) => ["--dir", path]);
+  return ["--die-with-parent", "--unshare-all", "--share-net", ...systemPaths, "--dev", "/dev", "--proc", "/proc", "--tmpfs", "/tmp", ...sandboxTemp ? ["--dir", canonicalPath(sandboxTemp)] : [], ...directories, ...toolchains.flatMap((path) => ["--ro-bind", path, path]), ...workspacePaths.flatMap((path) => ["--bind", path, path]), "--chdir", canonicalRoot, "/bin/sh", "-lc", command];
+}
+function toolchainReadPaths(root) {
+  const executable = canonicalPath(process.execPath);
+  const pathEntries = (process.env.PATH ?? "").split(delimiter).filter(Boolean).map((path) => resolve(path));
+  const prefixes = ["/opt/homebrew", "/usr/local"].filter((prefix) => executable.startsWith(`${prefix}${sep}`) || pathEntries.some((path) => path.startsWith(`${prefix}${sep}`)));
+  const home = canonicalPath(homedir());
+  const managedHomeRuntime = [join(home, ".nvm", "versions", "node"), join(home, ".asdf", "installs", "node"), join(home, ".volta", "tools", "image", "node")].find((prefix) => executable.startsWith(`${prefix}${sep}`));
+  const runtimeRoot = prefixes.length ? [] : managedHomeRuntime ? [executable.slice(0, executable.indexOf(`${sep}bin${sep}`, managedHomeRuntime.length))] : [dirname(executable)];
+  return [.../* @__PURE__ */ new Set([...prefixes, ...runtimeRoot])].filter((path) => path !== root && !path.startsWith(`${root}${sep}`));
+}
+function sandboxWorkspacePaths(root, protectedPaths) {
+  if (!protectedPaths.some((path) => path === root || path.startsWith(`${root}${sep}`)))
+    return [root];
+  return [...new Set(readdirSync(root).flatMap((name) => {
+    try {
+      return [canonicalPath(join(root, name))];
+    } catch {
+      return [];
+    }
+  }))].filter((candidate) => candidate !== root && candidate.startsWith(`${root}${sep}`)).filter((candidate) => !protectedPaths.some((path) => path === candidate || path.startsWith(`${candidate}${sep}`) || candidate.startsWith(`${path}${sep}`)));
+}
+function canonicalPath(path) {
+  let current = resolve(path);
+  const suffix = [];
+  while (!existsSync(current)) {
+    const parent = dirname(current);
+    if (parent === current)
+      break;
+    suffix.unshift(current.slice(parent.length + 1));
+    current = parent;
+  }
+  return resolve(realpathSync(current), ...suffix);
+}
+function pathAncestors(path) {
+  const values = [];
+  let current = resolve(path);
+  while (true) {
+    values.unshift(current);
+    const parent = dirname(current);
+    if (parent === current)
+      return values;
+    current = parent;
+  }
+}
+function toolEnvironment(sandboxTemp = null) {
+  const env = {};
+  for (const name of ["PATH", "HOME", "TMPDIR", "TMP", "TEMP", "LANG", "LC_ALL", "SHELL", "TERM", "USER"])
+    if (process.env[name] !== void 0)
+      env[name] = process.env[name];
+  if (sandboxTemp) {
+    env.TMPDIR = sandboxTemp;
+    env.TMP = sandboxTemp;
+    env.TEMP = sandboxTemp;
+  }
+  if (process.platform === "darwin") {
+    const developer = ["/Library/Developer/CommandLineTools", "/Applications/Xcode.app/Contents/Developer"].find(existsSync);
+    if (developer)
+      env.DEVELOPER_DIR = developer;
+  }
+  Object.assign(env, gitIdentityEnvironment());
+  return env;
+}
+function gitIdentityEnvironment() {
+  try {
+    const source = readFileSync(join(homedir(), ".gitconfig"), "utf8");
+    const user = source.match(/^\[user\]\s*\n((?:[ \t].*(?:\n|$))*)/m)?.[1] ?? "";
+    const name = user.match(/^\s*name\s*=\s*(.+)$/m)?.[1]?.trim();
+    const email = user.match(/^\s*email\s*=\s*(.+)$/m)?.[1]?.trim();
+    return { ...name ? { GIT_AUTHOR_NAME: name, GIT_COMMITTER_NAME: name } : {}, ...email ? { GIT_AUTHOR_EMAIL: email, GIT_COMMITTER_EMAIL: email } : {}, GIT_CONFIG_GLOBAL: "/dev/null" };
+  } catch {
+    return { GIT_CONFIG_GLOBAL: "/dev/null" };
+  }
+}
+function estimateMessages(messages) {
+  return Math.ceil(JSON.stringify(messages).length / 4);
+}
+function integerSetting(value, fallback) {
+  if (value === void 0)
+    return fallback;
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed <= 0)
+    throw new Error("Pi token settings must be positive integers");
+  return parsed;
+}
+function messageText(message) {
+  const value = message;
+  if (value.role === "user")
+    return typeof value.content === "string" ? value.content : value.content.map((item) => item.type === "text" ? item.text : "[image]").join(" ");
+  if (value.role === "assistant")
+    return value.content.map((item) => item.type === "text" ? item.text : item.type === "thinking" ? item.thinking : `[tool:${item.name}]`).join(" ");
+  return value.content.map((item) => item.type === "text" ? item.text : "[image]").join(" ");
+}
+function assistantResponseText(message) {
+  const value = message;
+  if (value.role !== "assistant")
+    return messageText(message);
+  return value.content.filter((item) => item.type === "text").map((item) => normalizeAssistantText(item.text)).filter(Boolean).join("\n");
+}
+function sameHandoff(left, right) {
+  return left.outcome === right.outcome && left.evidence.length === right.evidence.length && left.evidence.every((value, index) => value === right.evidence[index]);
+}
+function hasAgentToolCall(message, name) {
+  return message.role === "assistant" && message.content.some((item) => item.type === "toolCall" && item.name === name);
+}
+if (process.argv[1] && resolve(process.argv[1]) === resolve(fileURLToPath(import.meta.url)))
+  await runPiWorker();
+export {
+  assistantResponseText,
+  bashTimeoutMs,
+  compactMessages,
+  compactMessagesToTokenBudget,
+  linuxSandboxArgs,
+  resolveContextPolicy,
+  runBashCommand,
+  runPiWorker,
+  sandboxWorkspacePaths,
+  scopedRunnerPath,
+  snapshotModelConfig
+};