shellTool(process.cwd()),

          ...(active.length === 0 ? [] : [skillTool(active)]),

          openagentsTool(),

          goalTool(goalStore),

          // The goal tool follows the goal: a session with no goal declares

          // nothing about goals, and the objective itself reaches the model by

          // riding the outgoing turn (OpenAgentsInc/openagents#60), not by

          // being asked for. Re-declaration per turn is what makes the tool

          // appear the turn after `/goal` sets one.

          ...(goalStore.getGoal() === undefined ? [] : [goalTool(goalStore)]),

          ...(setup === undefined ? [] : [delegateTool(setup.delegation)]),

          capability,

          ...visiblePlugins().map((plugin) => {

 * - Supports `/goal <objective>`, `/goal status`, `/goal clear`, `/goal pause`, `/goal resume`.

 * - Easter egg: `/goooooal` with arbitrary repeated `o`s resolves to `/goal`.

 * - Tracks status, token budget, tokens used, elapsed time, and turn progression.

 * - Exposes `goal` tool to the agent model (`get`, `update`, `complete`, `block`).

 * - Exposes `goal` tool to the agent model for reporting state changes

 *   (`complete`, `block`, `pause`, `resume`). Reading the goal is not an

 *   action: the active objective rides every outgoing turn via the

 *   continuation prompts below, so the model already holds it.

 * - Generates continuation prompts and budget exhaustion prompts for multi-turn alignment.

 */

  ].join("\n");

}

/** Model tool allowing the agent to inspect or complete its goal */

/**

 * Model tool for reporting goal state changes.

 *

 * There is deliberately no `get`: the goal's objective, status, and remaining

 * budget already ride every outgoing turn, so reading state the model holds

 * would only spend a tool round rediscovering it

 * (OpenAgentsInc/openagents#60). What remains are the genuine model

 * decisions — reporting that the goal finished, hit a wall, or should pause

 * or resume.

 */

export function goalTool(goalStore: GoalStore): CoderTool {

  return {

    name: "goal",

    description:

      "Inspect, update, or complete the active persistent task goal for this session. " +

      "Call this with action='get' to inspect current goal status & budget, or action='complete'/'block' to update status.",

      "Report a state change on the active persistent task goal for this session. " +

      "The goal's objective, status, and budget already accompany each turn; " +

      "call this with action='complete' when the goal is done and verified, or 'block'/'pause'/'resume' to update its status.",

    parameters: {

      type: "object",

      properties: {

        action: {

          type: "string",

          enum: ["get", "complete", "block", "pause", "resume"],

          enum: ["complete", "block", "pause", "resume"],

          description: "The goal operation to perform.",

        },

        notes: {

      required: ["action"],

    },

    async run(args: Record<string, unknown>): Promise<string> {

      const action = String(args.action || "get");

      const action = String(args.action ?? "");

      const current = goalStore.getGoal();

      if (action === "get") {

        if (current === undefined) {

          return JSON.stringify({ active: false, message: "No active goal set." });

        }

        return JSON.stringify({

          active: true,

          id: current.id,

          objective: current.objective,

          status: current.status,

          tokensUsed: current.tokensUsed,

          tokenBudget: current.tokenBudget,

          timeUsedSeconds: current.timeUsedSeconds,

        });

      }

      if (current === undefined) {

        return "Refusal: No active goal to update.";

      }

import type { CoderTool } from "./coder-tools.js";

import {

  formatGoalNotice,

  goalBudgetExhaustedPrompt,

  goalContinuationPrompt,

  isGoalSlashCommand,

  parseGoalSlashCommand,

  type GoalStore,

        this.source.useContext !== undefined

          ? prompt

          : `${this.standing}\n\n---\n\n${prompt}`;

      const outgoing = attached === undefined ? sent : `${sent}\n\n${attached}`;

      const withAttached = attached === undefined ? sent : `${sent}\n\n${attached}`;

      // The goal is standing state, so it rides the turn rather than waiting

      // for the model to ask: an active objective goes out with every prompt,

      // and a spent budget goes out as the instruction to wind down. Any other

      // status — paused, completed, blocked — has nothing for the model to act

      // on, and injects nothing.

      const goal = this.goalStore?.getGoal();

      const goalNote =

        goal === undefined

          ? undefined

          : goal.status === "active"

            ? goalContinuationPrompt(goal)

            : goal.status === "budget_limited"

              ? goalBudgetExhaustedPrompt(goal)

              : undefined;

      const outgoing = goalNote === undefined ? withAttached : `${withAttached}\n\n${goalNote}`;

      for await (const chunk of this.source.reply(outgoing, controller.signal)) {

        if (controller.signal.aborted) break;

    // Tool interactions

    const tool = goalTool(store);

    const getRes = JSON.parse(await tool.run({ action: "get" }, new AbortController().signal));

    expect(getRes.active).toBe(true);

    expect(getRes.status).toBe("budget_limited");

    const completeRes = await tool.run({ action: "complete" }, new AbortController().signal);

    expect(completeRes).toContain("marked as completed");

    expect(store.getGoal()?.status).toBe("completed");

    expect(store.clearGoal()).toBe(true);

    expect(store.getGoal()).toBeUndefined();

  });

  it("no longer offers or accepts a get action", async () => {

    // Reading the goal stopped being an action (issue #60): the objective

    // rides every outgoing turn, so the tool keeps only the state changes the

    // model genuinely decides.

    const store = new InMemoryGoalStore();

    store.setGoal("Write test suite");

    const tool = goalTool(store);

    const parameters = tool.parameters as {

      properties: { action: { enum: string[] } };

    };

    expect(parameters.properties.action.enum).toEqual(["complete", "block", "pause", "resume"]);

    expect(tool.description).not.toContain("'get'");

    const rejected = await tool.run({ action: "get" }, new AbortController().signal);

    expect(rejected).toContain("Unknown action");

    expect(store.getGoal()?.status).toBe("active");

  });

});

describe("formatGoalNotice and Prompts", () => {

    expect(session.snapshot().goal).toBeUndefined();

  });

});

describe("goal injection into the outgoing turn", () => {

  /** A source that records the prompts it was actually handed. */

  const recording = (sent: string[]): ReplySource => ({

    model: "scripted",

    async *reply(prompt) {

      sent.push(prompt);

      yield { type: "text", value: "ok" } as const;

    },

  });

  const withStore = (sent: string[], store: InMemoryGoalStore): CoderSession =>

    new CoderSession(

      recording(sent),

      "repo",

      "main",

      undefined,

      undefined,

      undefined,

      undefined,

      undefined,

      store,

    );

  it("puts the active goal's objective on the prompt without being asked", async () => {

    const sent: string[] = [];

    const store = new InMemoryGoalStore();

    store.setGoal("Ship the goal injection path", 50000);

    const session = withStore(sent, store);

    await session.submit("hi");

    expect(sent).toHaveLength(1);

    expect(sent[0]).toContain("hi");

    expect(sent[0]).toContain("Continue working toward the active task goal.");

    expect(sent[0]).toContain("Ship the goal injection path");

    expect(sent[0]).toContain("Token budget remaining: 50,000 tokens");

  });

  it("sends the prompt untouched when no goal is set", async () => {

    const sent: string[] = [];

    const session = withStore(sent, new InMemoryGoalStore());

    await session.submit("hi");

    expect(sent).toEqual(["hi"]);

  });

  it("injects the wind-down prompt when the budget is exhausted", async () => {

    const sent: string[] = [];

    const store = new InMemoryGoalStore();

    store.setGoal("Ship the goal injection path", 1000);

    store.addUsage(1500, 5);

    expect(store.getGoal()?.status).toBe("budget_limited");

    const session = withStore(sent, store);

    await session.submit("continue");

    expect(sent).toHaveLength(1);

    expect(sent[0]).toContain("reached its configured token budget");

    expect(sent[0]).toContain("Ship the goal injection path");

  });

  it("injects nothing for a paused goal", async () => {

    const sent: string[] = [];

    const store = new InMemoryGoalStore();

    store.setGoal("Ship the goal injection path");

    store.updateStatus("paused");

    const session = withStore(sent, store);

    await session.submit("hi");

    expect(sent).toEqual(["hi"]);

  });

});

    {

      "ref": "packages/sovereign-identity/src/machinery/retire.ts#ReadOnlyLegacyPlaintextGuardInterface.deleteFile",

      "reason": "Fail-closed half of the read-only legacy-plaintext guard: it exists to REFUSE deleting a protected legacy file while verification is active. Its sibling writeFile is unflagged only because .writeFile collides with common production dot-accesses; dropping the delete refusal would leave the guard able to block writes but not deletions."

    },

    {

      "ref": "packages/openagents-cli/src/coder-goals.ts#goalBudgetExhaustedPrompt",

      "reason": "Goal prompt helper for autonomous turn continuation when token budget is exhausted; used by goal test suite and future autonomous loop."

    },

    {

      "ref": "packages/openagents-cli/src/coder-goals.ts#goalContinuationPrompt",

      "reason": "Goal prompt helper for autonomous turn continuation toward active goal; used by goal test suite and future autonomous loop."

    }

  ]

}