import { openLocalThread, threadAnnouncement, threadSyncWanted } from "./coder-local-thread.js";

import { ThreadTranscriptWriter } from "./coder-transcript.js";

import { delegateTool, openagentsTool, shellTool, skillTool } from "./coder-tools.js";

import { InMemoryGoalStore, goalTool } from "./coder-goals.js";

import {

  describeLoad,

  invokePlugin,

            }

          : undefined;

      const goalStore = new InMemoryGoalStore();

      const session = new CoderSession(

        source,

        workspace.repository,

            ? { initial: initialTier, build: buildTier }

            : undefined),

        (prompt) => capabilityRetrieval(prompt),

        goalStore,

      );

      // The resumed thread's history goes on the session before anything new,

          shellTool(process.cwd()),

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

          openagentsTool(),

          goalTool(goalStore),

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

          capability,

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

/**

 * Persistent task goals for `openagents coder`.

 *

 * Inspired by Codex's goal extension architecture:

 * - Persists an active high-level task goal across turns.

 * - 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`).

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

 */

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

export type GoalStatus =

  | "active"

  | "paused"

  | "completed"

  | "abandoned"

  | "budget_limited"

  | "blocked";

export interface PersistentGoal {

  readonly id: string;

  readonly objective: string;

  status: GoalStatus;

  readonly tokenBudget?: number;

  tokensUsed: number;

  timeUsedSeconds: number;

  readonly createdAt: number;

  updatedAt: number;

}

export interface GoalStore {

  getGoal(): PersistentGoal | undefined;

  setGoal(objective: string, tokenBudget?: number): PersistentGoal;

  updateStatus(status: GoalStatus): PersistentGoal | undefined;

  clearGoal(): boolean;

  addUsage(tokens: number, elapsedSeconds: number): void;

}

/** In-memory goal manager for a CoderSession */

export class InMemoryGoalStore implements GoalStore {

  private currentGoal: PersistentGoal | undefined;

  getGoal(): PersistentGoal | undefined {

    return this.currentGoal;

  }

  setGoal(objective: string, tokenBudget?: number): PersistentGoal {

    const now = Date.now();

    const goal: PersistentGoal = {

      id: `goal_${Math.random().toString(36).slice(2, 10)}`,

      objective: objective.trim(),

      status: "active",

      ...(tokenBudget !== undefined && tokenBudget > 0 ? { tokenBudget } : {}),

      tokensUsed: 0,

      timeUsedSeconds: 0,

      createdAt: now,

      updatedAt: now,

    };

    this.currentGoal = goal;

    return goal;

  }

  updateStatus(status: GoalStatus): PersistentGoal | undefined {

    if (this.currentGoal === undefined) return undefined;

    this.currentGoal.status = status;

    this.currentGoal.updatedAt = Date.now();

    return this.currentGoal;

  }

  clearGoal(): boolean {

    if (this.currentGoal === undefined) return false;

    this.currentGoal = undefined;

    return true;

  }

  addUsage(tokens: number, elapsedSeconds: number): void {

    if (this.currentGoal === undefined || this.currentGoal.status !== "active") return;

    this.currentGoal.tokensUsed += tokens;

    this.currentGoal.timeUsedSeconds += Math.max(0, Math.round(elapsedSeconds));

    this.currentGoal.updatedAt = Date.now();

    if (

      this.currentGoal.tokenBudget !== undefined &&

      this.currentGoal.tokensUsed >= this.currentGoal.tokenBudget

    ) {

      this.currentGoal.status = "budget_limited";

    }

  }

}

/** Check if a prompt matches `/goal` or repeated `/goooooal` */

export function isGoalSlashCommand(input: string): boolean {

  const trimmed = input.trim();

  if (!trimmed.startsWith("/")) return false;

  return /^\/g(o+)al(\s+.*)?$/is.test(trimmed);

}

export interface GoalCommandParseResult {

  kind: "set" | "clear" | "pause" | "resume" | "status";

  objective?: string;

  tokenBudget?: number;

}

/** Parse `/goal ...` arguments into a structured action */

export function parseGoalSlashCommand(input: string): GoalCommandParseResult | undefined {

  const trimmed = input.trim();

  const match = /^\/g(?:o+)al(?:\s+(.*))?$/is.exec(trimmed);

  if (!match) return undefined;

  const rawArgs = match[1]?.trim() ?? "";

  if (rawArgs.length === 0 || rawArgs.toLowerCase() === "status") {

    return { kind: "status" };

  }

  if (rawArgs.toLowerCase() === "clear") {

    return { kind: "clear" };

  }

  if (rawArgs.toLowerCase() === "pause") {

    return { kind: "pause" };

  }

  if (rawArgs.toLowerCase() === "resume") {

    return { kind: "resume" };

  }

  // Parse optional token budget prefix e.g. "--budget 50000 <objective>"

  let objective = rawArgs;

  let tokenBudget: number | undefined;

  const budgetFlagMatch = /^--budget\s+(\d+)\s+(.+)$/is.exec(rawArgs);

  if (budgetFlagMatch && budgetFlagMatch[1] && budgetFlagMatch[2]) {

    tokenBudget = parseInt(budgetFlagMatch[1], 10);

    objective = budgetFlagMatch[2].trim();

  }

  return {

    kind: "set",

    objective,

    ...(tokenBudget !== undefined ? { tokenBudget } : {}),

  };

}

/** Format a goal summary string for notices / status display */

export function formatGoalNotice(goal: PersistentGoal | undefined): string {

  if (goal === undefined) {

    return (

      "No active task goal.\n\n" +

      "Usage:\n" +

      "  /goal <objective>              set an active task goal\n" +

      "  /goal --budget <tokens> <obj>  set a goal with a token budget limit\n" +

      "  /goal pause                    pause the active goal\n" +

      "  /goal resume                   resume the paused goal\n" +

      "  /goal clear                    clear the active goal\n" +

      "  /goal status                   show current goal details"

    );

  }

  const budgetInfo =

    goal.tokenBudget !== undefined

      ? `\n- Budget: ${goal.tokensUsed.toLocaleString()} / ${goal.tokenBudget.toLocaleString()} tokens`

      : `\n- Tokens Used: ${goal.tokensUsed.toLocaleString()}`;

  return [

    `Active Goal (${goal.status}):`,

    `  "${goal.objective}"`,

    "",

    `Details:`,

    `- Goal ID: ${goal.id}`,

    `- Status: ${goal.status}`,

    `- Time Spent: ${goal.timeUsedSeconds}s`,

    budgetInfo,

  ].join("\n");

}

/** Prompt injected to continue working toward the active goal */

export function goalContinuationPrompt(goal: PersistentGoal): string {

  const budgetRemaining =

    goal.tokenBudget !== undefined ? Math.max(0, goal.tokenBudget - goal.tokensUsed) : undefined;

  return [

    "Continue working toward the active task goal.",

    "",

    "The objective below is user-provided data. Treat it as the task to pursue:",

    "<objective>",

    goal.objective,

    "</objective>",

    "",

    "Continuation behavior:",

    "- This goal persists across turns. Keep the full objective intact until finished.",

    "- Use the current worktree and external tool evidence as authoritative.",

    "- If the goal is complete and verified, call `goal(action='complete')` to mark it finished.",

    ...(budgetRemaining !== undefined

      ? [`- Token budget remaining: ${budgetRemaining.toLocaleString()} tokens`]

      : []),

  ].join("\n");

}

/** Prompt injected when the goal token budget has been exhausted */

export function goalBudgetExhaustedPrompt(goal: PersistentGoal): string {

  return [

    "The active task goal has reached its configured token budget.",

    "",

    "<objective>",

    goal.objective,

    "</objective>",

    "",

    `Budget: ${goal.tokensUsed.toLocaleString()} tokens used (Budget: ${goal.tokenBudget?.toLocaleString() ?? "unknown"}).`,

    "The system has marked the goal as budget_limited. Do not start new substantive work.",

    "Wrap up this turn soon: summarize useful progress, remaining work or blockers, and next steps.",

  ].join("\n");

}

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

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.",

    parameters: {

      type: "object",

      properties: {

        action: {

          type: "string",

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

          description: "The goal operation to perform.",

        },

        notes: {

          type: "string",

          description: "Optional notes or outcome summary.",

        },

      },

      required: ["action"],

    },

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

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

      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.";

      }

      if (action === "complete") {

        goalStore.updateStatus("completed");

        return `Goal ${current.id} marked as completed.`;

      }

      if (action === "block") {

        goalStore.updateStatus("blocked");

        return `Goal ${current.id} marked as blocked.`;

      }

      if (action === "pause") {

        goalStore.updateStatus("paused");

        return `Goal ${current.id} marked as paused.`;

      }

      if (action === "resume") {

        goalStore.updateStatus("active");

        return `Goal ${current.id} marked as active.`;

      }

      return `Unknown action: ${action}`;

    },

  };

}

import { VERSION } from "./version.js";

import type { CoderTask, CoderTaskId, CoderTaskRegistry } from "./coder-tasks.js";

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

import {

  formatGoalNotice,

  isGoalSlashCommand,

  parseGoalSlashCommand,

  type GoalStore,

  type PersistentGoal,

} from "./coder-goals.js";

/** What a reply source produces. One entry kind per member. */

export type ReplyChunk =

   * then no renderer draws a fleet at all.

   */

  readonly tasks: ReadonlyArray<CoderTask>;

  /** The active persistent goal for this session, if one is set. */

  readonly goal?: PersistentGoal | undefined;

  /**

   * Plugin loads and refusals, oldest first.

   *

   * stamped with its provenance the moment the call arrives.

   */

  private readonly pluginTools = new Map<string, CoderPluginProvenance>();

  private readonly goalStore: GoalStore | undefined;

  constructor(

    private source: ReplySource,

     * the turn nothing. The model is never expected to consult a registry.

     */

    private readonly retrieve?: (prompt: string) => Promise<string | undefined>,

    goalStore?: GoalStore | undefined,

  ) {

    this.tier = tiers?.initial;

    // A child reporting progress has to reach the renderer, and the renderer

    // Handed over before the first turn, so a source that composes a system

    // message has the context when it composes one.

    this.goalStore = goalStore;

    if (standing !== undefined && standing.length > 0) this.source.useContext?.(standing);

  }

      turns: this.turnCount,

      budget: this.source.budget,

      tasks: this.delegation?.registry.list() ?? [],

      goal: this.goalStore?.getGoal(),

      pluginEvents: this.pluginEvents.map((event) => ({

        ...event,

        plugin: { ...event.plugin },

      return;

    }

    // `/goal` manages persistent task goals across turns.

    if (isGoalSlashCommand(prompt)) {

      this.entries.push({ role: "you", text: prompt, settled: true, at: Date.now() });

      const parsed = parseGoalSlashCommand(prompt);

      if (this.goalStore === undefined) {

        this.notice("This session does not have goal storage configured.");

        this.emit();

        return;

      }

      if (!parsed || parsed.kind === "status") {

        this.notice(formatGoalNotice(this.goalStore.getGoal()));

      } else if (parsed.kind === "clear") {

        const cleared = this.goalStore.clearGoal();

        this.notice(cleared ? "Cleared active task goal." : "No active task goal to clear.");

      } else if (parsed.kind === "pause") {

        const updated = this.goalStore.updateStatus("paused");

        this.notice(updated ? `Paused task goal: "${updated.objective}"` : "No active task goal to pause.");

      } else if (parsed.kind === "resume") {

        const updated = this.goalStore.updateStatus("active");

        this.notice(updated ? `Resumed task goal: "${updated.objective}"` : "No task goal to resume.");

      } else if (parsed.kind === "set" && parsed.objective) {

        const goal = this.goalStore.setGoal(parsed.objective, parsed.tokenBudget);

        this.notice(

          `Set active goal: "${goal.objective}"` +

            (goal.tokenBudget !== undefined ? ` (Budget: ${goal.tokenBudget.toLocaleString()} tokens)` : "") +

            "\nCall /goal for details, or /goal clear to remove.",

        );

      }

      this.emit();

      return;

    }

    // `/export` is not a turn either: it writes what has already happened.

    if (/^\/export\s*$/.test(prompt.trim())) {

      this.entries.push({ role: "you", text: prompt, settled: true, at: Date.now() });

        [

          "Commands",

          "  /help                       this list",

          "  /goal [<objective>]         set, inspect, or manage the task goal",

          "  /system                     what the model is told: tools, skills, and its",

          "                              standing context",

          "  /skills                     choose which skills the model is offered",

        [

          "Commands:",

          "  /help     this list",

          "  /goal     set, inspect, or manage the task goal",

          "  /system   what the model is told, including tools and skills",

          "  /skills   choose which skills the model is offered",

          "  /resume   list or select a recent foreign coding session",

    const controller = new AbortController();

    this.controller = controller;

    const turnStart = Date.now();

    // Counted here rather than on completion. A turn that is happening is a

    // turn, and counting it only once it settled is what made the status line

    // read `0 replies` under a reply the reader was watching arrive.

                : { cacheReadInputTokens: chunk.cacheReadInputTokens }),

            };

          }

          if (this.goalStore !== undefined) {

            const totalTokens = (chunk.promptTokens ?? 0) + (chunk.completionTokens ?? 0);

            this.goalStore.addUsage(totalTokens, (Date.now() - turnStart) / 1000);

          }

        } else {

          this.applyToolResult(chunk);

        }

      const facts = [snapshot.repository, snapshot.branch, snapshot.model];

      if (snapshot.reasoning !== undefined) facts.push(`thinking ${snapshot.reasoning}`);

      if (snapshot.budget !== undefined) facts.push(snapshot.budget);

      if (snapshot.goal !== undefined && snapshot.goal.status === "active") {

        const goalSnippet = snapshot.goal.objective.length > 25

          ? snapshot.goal.objective.slice(0, 22) + "…"

          : snapshot.goal.objective;

        facts.push(`goal: "${goalSnippet}"`);

      }

      let where = "";

      for (let from = 0; from < facts.length; from += 1) {

        const candidate = `${DIM}${facts.slice(from).join(" · ")}${RESET}`;

import { describe, expect, it } from "vitest";

import {

  formatGoalNotice,

  goalBudgetExhaustedPrompt,

  goalContinuationPrompt,

  goalTool,

  InMemoryGoalStore,

  isGoalSlashCommand,

  parseGoalSlashCommand,

} from "../src/coder-goals.js";

describe("isGoalSlashCommand", () => {

  it("matches standard /goal and variations", () => {

    expect(isGoalSlashCommand("/goal")).toBe(true);

    expect(isGoalSlashCommand("/goal foo bar")).toBe(true);

    expect(isGoalSlashCommand("/goooal build the thing")).toBe(true);

    expect(isGoalSlashCommand("/goooooooooal")).toBe(true);

    expect(isGoalSlashCommand("  /goal clear  ")).toBe(true);

  });

  it("does not match non-goal slash commands or regular text", () => {

    expect(isGoalSlashCommand("/help")).toBe(false);

    expect(isGoalSlashCommand("/reload")).toBe(false);

    expect(isGoalSlashCommand("what is our goal?")).toBe(false);

    expect(isGoalSlashCommand("goal")).toBe(false);

  });

});

describe("parseGoalSlashCommand", () => {

  it("parses status command", () => {

    expect(parseGoalSlashCommand("/goal")).toEqual({ kind: "status" });

    expect(parseGoalSlashCommand("/goal status")).toEqual({ kind: "status" });

    expect(parseGoalSlashCommand("/goooal")).toEqual({ kind: "status" });

  });

  it("parses control commands", () => {

    expect(parseGoalSlashCommand("/goal clear")).toEqual({ kind: "clear" });

    expect(parseGoalSlashCommand("/goal pause")).toEqual({ kind: "pause" });

    expect(parseGoalSlashCommand("/goal resume")).toEqual({ kind: "resume" });

  });

  it("parses set command with objective", () => {

    expect(parseGoalSlashCommand("/goal build persistent goals")).toEqual({

      kind: "set",

      objective: "build persistent goals",

    });

  });

  it("parses set command with --budget flag", () => {

    expect(parseGoalSlashCommand("/goal --budget 25000 refactor database schema")).toEqual({

      kind: "set",

      objective: "refactor database schema",

      tokenBudget: 25000,

    });

  });

});

describe("InMemoryGoalStore and goalTool", () => {

  it("manages goal lifecycle and usage tracking", async () => {

    const store = new InMemoryGoalStore();

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

    const goal = store.setGoal("Write test suite", 10000);

    expect(goal.objective).toBe("Write test suite");

    expect(goal.status).toBe("active");

    expect(goal.tokenBudget).toBe(10000);

    expect(goal.tokensUsed).toBe(0);

    store.addUsage(2500, 10);

    expect(store.getGoal()?.tokensUsed).toBe(2500);

    expect(store.getGoal()?.timeUsedSeconds).toBe(10);

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

    // Exceeding budget marks goal budget_limited

    store.addUsage(8000, 15);

    expect(store.getGoal()?.tokensUsed).toBe(10500);

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

    // 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");

    // Clear

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

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

  });

});

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

  it("formats notice when no goal set", () => {

    const notice = formatGoalNotice(undefined);

    expect(notice).toContain("No active task goal.");

    expect(notice).toContain("Usage:");

  });

  it("formats notice with active goal and budget", () => {

    const store = new InMemoryGoalStore();

    const goal = store.setGoal("Implement feature", 50000);

    store.addUsage(1200, 5);

    const notice = formatGoalNotice(goal);

    expect(notice).toContain('Active Goal (active):');

    expect(notice).toContain('"Implement feature"');

    expect(notice).toContain("Budget: 1,200 / 50,000 tokens");

    expect(notice).toContain("Time Spent: 5s");

  });

  it("generates continuation prompt", () => {

    const store = new InMemoryGoalStore();

    const goal = store.setGoal("Implement feature", 50000);

    store.addUsage(10000, 20);

    const prompt = goalContinuationPrompt(goal);

    expect(prompt).toContain("Continue working toward the active task goal.");

    expect(prompt).toContain("<objective>\nImplement feature\n</objective>");

    expect(prompt).toContain("Token budget remaining: 40,000 tokens");

  });

  it("generates budget exhausted prompt", () => {

    const store = new InMemoryGoalStore();

    const goal = store.setGoal("Implement feature", 5000);

    store.addUsage(6000, 30);

    const prompt = goalBudgetExhaustedPrompt(goal);

    expect(prompt).toContain("reached its configured token budget");

    expect(prompt).toContain("budget_limited");

  });

});

import { tmpdir } from "node:os";

import { join } from "node:path";

import { describe, expect, it } from "vitest";

import { InMemoryGoalStore } from "../src/coder-goals.js";

import {

  CoderSession,

    expect(tool?.tool?.plugin).toBeUndefined();

  });

});

describe("the /goal command in CoderSession", () => {

  it("handles /goal lifecycle via session prompts", async () => {

    const store = new InMemoryGoalStore();

    const session = new CoderSession(

      scripted(["hello"]),

      "repo",

      "main",

      undefined,

      undefined,

      undefined,

      undefined,

      undefined,

      store,

    );

    // Initial status notice

    await session.submit("/goal");

    const snap1 = session.snapshot();

    const notice1 = snap1.entries.find((e) => e.role === "notice");

    expect(notice1?.text).toContain("No active task goal.");

    // Set goal

    await session.submit("/goal Build persistent task goals");

    expect(store.getGoal()?.objective).toBe("Build persistent task goals");

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

    expect(session.snapshot().goal?.objective).toBe("Build persistent task goals");

    // Pause goal

    await session.submit("/goal pause");

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

    // Resume goal

    await session.submit("/goal resume");

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

    // Clear goal

    await session.submit("/goal clear");

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

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

  });

});