@chengchenccc/oh-my-agent 0.2.0-rc.2 → 0.2.0-rc.3

package/dist/core/goals/runtime.js

@@ -0,0 +1,241 @@
+import { accountTurn, accrueUsage, completeGoal, completionBudgetReport, createGoal, isAccountingStatus, pauseGoal, renderGoalPrompt, resumeGoal, } from "./state.js";
+const NO_PROGRESS_LIMIT = 3;
+export class GoalRuntime {
+    persist;
+    notify;
+    #state = null;
+    #noProgressTurns = 0;
+    #interviewing = false;
+    /** Set by complete(): the settled run's usage still has to land on the
+     *  completed goal (the tool fired mid-run, before usage existed). */
+    #pendingFinalFlush = false;
+    constructor(
+    /** Persist a transition (session event). Called on EVERY mutation so a
+     *  quit right after /goal pause still survives resume. */
+    /** Persist a transition. `recordCompletion` is false for the transition
+     *  that still owes a usage flush (see complete()). */
+    persist = () => { }, 
+    /** Surface a transition for the UI (status line). */
+    notify = () => { }) {
+        this.persist = persist;
+        this.notify = notify;
+    }
+    get state() {
+        return this.#state;
+    }
+    get goal() {
+        return this.#state?.goal ?? null;
+    }
+    get interviewing() {
+        return this.#interviewing;
+    }
+    /** Whether the goal tool should be mounted for the next run. */
+    get toolWanted() {
+        return this.#interviewing || this.#state?.enabled === true;
+    }
+    beginInterview() {
+        this.#interviewing = true;
+    }
+    /** Resume replay (session event): a live goal comes back PAUSED. */
+    restore(state) {
+        this.#state = state;
+    }
+    #commit(next, options) {
+        this.#state = next;
+        this.persist(next, options?.recordCompletion !== false);
+    }
+    /** Start a goal, or REPLACE the current one (fresh counters and budget).
+     *  A PAUSED goal cannot be silently overwritten: resume it and use set, or
+     *  drop it first — otherwise parked work would vanish without a word. */
+    create(objective, tokenBudget) {
+        if (this.#state?.goal.status === "paused") {
+            throw new Error("goal is paused — /goal resume then /goal set to replace it, or /goal drop first");
+        }
+        const replacing = this.#state !== null;
+        const next = createGoal(objective, tokenBudget);
+        this.#interviewing = false;
+        this.#noProgressTurns = 0;
+        this.#commit(next);
+        this.notify(replacing
+            ? "goal replaced — new objective active; model declares completion"
+            : "goal set — model declares completion via the goal tool; interrupt pauses");
+        return next;
+    }
+    pause() {
+        if (!this.#state)
+            return;
+        this.#commit(pauseGoal(this.#state));
+        this.notify("goal paused — /goal resume continues it");
+    }
+    resume() {
+        if (!this.#state)
+            return;
+        this.#commit(resumeGoal(this.#state));
+        this.#noProgressTurns = 0;
+        this.notify("goal resumed — continuing on the next turn");
+    }
+    drop() {
+        const dropped = this.#state?.goal ?? null;
+        if (!this.#state)
+            return null;
+        this.#interviewing = false;
+        this.#commit(null);
+        if (dropped)
+            this.notify(`goal dropped — ${dropped.objective}`);
+        return dropped;
+    }
+    /** Set the TOTAL token budget (not an increment); accumulated usage is
+     *  kept. Raising it past tokensUsed resumes a budget-limited goal; lowering
+     *  it below re-limits. Returns a continuation prompt when the goal resumed,
+     *  else null.
+     *
+     *  A PAUSED goal must be resumed first: changing the budget of work that is
+     *  not running silently rewrites the terms of a decision the user already
+     *  parked. */
+    setBudget(budget) {
+        const state = this.#state;
+        if (!state)
+            return null;
+        if (state.goal.status === "paused") {
+            throw new Error("goal is paused — /goal resume before changing its budget");
+        }
+        if (budget !== undefined && (!Number.isInteger(budget) || budget <= 0)) {
+            throw new Error("budget must be a positive integer");
+        }
+        const goal = { ...state.goal, tokenBudget: budget, updatedAt: Date.now() };
+        if (budget !== undefined && goal.tokensUsed >= budget) {
+            goal.status = "budget-limited";
+            this.#commit({ ...state, goal });
+            this.notify(`goal budget-limited (${goal.tokensUsed} ≥ ${budget})`);
+            return null;
+        }
+        if (state.goal.status === "budget-limited") {
+            goal.status = "active";
+            this.#commit({ ...state, enabled: true, goal });
+            this.notify(`goal budget raised to ${budget ?? "unbounded"} — resumed`);
+            return { prompt: renderGoalPrompt("continuation", goal) };
+        }
+        this.#commit({ ...state, goal });
+        this.notify(`goal budget set to ${budget ?? "unbounded"}`);
+        return null;
+    }
+    /** Flush the in-flight turn into the goal, then mark it complete. The
+     *  turn's provider usage is only known when the run SETTLES, so the final
+     *  flush is deferred there (#pendingFinalFlush) — the report the settle
+     *  returns covers the final turn, exactly like omp's flush-inside-
+     *  completeGoalFromTool. */
+    complete() {
+        const state = this.#state;
+        if (!state)
+            throw new Error("no goal to complete");
+        // The turn's usage is only known at settle, so the transition is committed
+        // WITHOUT the completion record; settleTurn flushes usage and commits
+        // again, and only THAT commit carries the final numbers (a record written
+        // here would state zero usage and the flush would write a second one).
+        this.#pendingFinalFlush = isAccountingStatus(state.goal);
+        const done = completeGoal(state);
+        this.#commit(done, { recordCompletion: false });
+        this.notify(`goal COMPLETE — ${done.goal.objective}`);
+    }
+    /** The status-bar indicator: the state plus the usage the user supervises
+     *  the goal with. The driver owns its wording. */
+    statusLabel() {
+        const goal = this.#state?.goal;
+        if (!goal)
+            return undefined;
+        const used = `${goal.tokensUsed} tok`;
+        const usage = goal.tokenBudget !== undefined ? `${used}/${goal.tokenBudget}` : used;
+        return `◎ goal ${goal.status} ${usage}`;
+    }
+    remainingTokens() {
+        const goal = this.#state?.goal;
+        if (!goal || goal.tokenBudget === undefined)
+            return null;
+        return Math.max(0, goal.tokenBudget - goal.tokensUsed);
+    }
+    /** The loop's post-turn decision. Fail-safe ordering: an interrupted or
+     *  failed turn PAUSES and never queues work (omp onTaskAborted flushes
+     *  with steering suppressed); a terminal transition reports; budget
+     *  crossing wraps up once; otherwise continue (or pause on a stall). */
+    settleTurn(turn) {
+        const state = this.#state;
+        if (!state)
+            return { action: "idle" };
+        // A complete/drop fired mid-run: fold the settled turn into the goal
+        // first so the report (and the persisted numbers) include it.
+        if (this.#pendingFinalFlush) {
+            this.#pendingFinalFlush = false;
+            const current = this.#state ?? state;
+            // accrueUsage, not accountTurn: the goal is already terminal, but the
+            // final turn's tokens still belong to it.
+            this.#commit({
+                ...current,
+                goal: accrueUsage(current.goal, turn.usage, turn.wallSeconds),
+            });
+        }
+        if (!isAccountingStatus(state.goal)) {
+            if (state.reason === "completed") {
+                return {
+                    action: "completed",
+                    objective: state.goal.objective,
+                    report: completionBudgetReport(this.#state?.goal ?? state.goal),
+                };
+            }
+            return { action: "idle" };
+        }
+        const accounted = accountTurn(state, turn.usage, turn.wallSeconds);
+        const current = accounted.state.goal;
+        if (turn.status !== "completed") {
+            this.#commit(pauseGoal(accounted.state));
+            const reason = `run ${turn.status} — goal paused; /goal resume continues`;
+            this.notify(reason);
+            return { action: "paused", reason };
+        }
+        if (accounted.crossedBudget) {
+            this.#commit(accounted.state);
+            return {
+                action: "budget-wrapup",
+                prompt: renderGoalPrompt("budget-limit", current),
+                tokensUsed: current.tokensUsed,
+                tokenBudget: current.tokenBudget ?? 0,
+            };
+        }
+        if (current.status !== "active") {
+            this.#commit(accounted.state);
+            return { action: "idle" };
+        }
+        this.#noProgressTurns = turn.usedTools ? 0 : this.#noProgressTurns + 1;
+        if (this.#noProgressTurns >= NO_PROGRESS_LIMIT) {
+            this.#commit(pauseGoal(accounted.state));
+            const reason = `${this.#noProgressTurns} goal turns without tool use — paused; /goal resume continues`;
+            this.notify(reason);
+            return { action: "paused", reason };
+        }
+        this.#commit(accounted.state);
+        return {
+            action: "continue",
+            prompt: renderGoalPrompt("continuation", current),
+            tokensUsed: current.tokensUsed,
+            ...(current.tokenBudget !== undefined ? { tokenBudget: current.tokenBudget } : {}),
+        };
+    }
+    /** omp goal-todo-context: a continuation has no visible user nudge, so the
+     *  live todo state must ride along or stale items silently rot. Appended
+     *  to continuation/budget prompts by the caller that owns the todo file. */
+    static renderTodoContext(items) {
+        if (items.length === 0)
+            return "";
+        const open = items.filter((i) => i.status !== "done" && i.status !== "cancelled").length;
+        const done = items.length - open;
+        const rows = items.map((i) => `- [${i.status === "in_progress" ? "in_progress" : i.status}] ${i.text}`);
+        return [
+            "<todo_context>",
+            "Persisted todos: live progress state for the current goal, not old transcript decoration; goal continuations lack a visible user nudge → treat as live state.",
+            "Before substantial work: compare the next action with the todos. If an item is stale, already finished, or no longer the active pointer, call `todo` first: mark it done or rewrite the list. Do not leave a stale in_progress while working on later phases.",
+            "",
+            `Overall: ${done}/${items.length} done, ${open} open.`,
+            ...rows,
+            "</todo_context>",
+        ].join("\n");
+    }
+}

package/dist/core/goals/state.d.ts

@@ -0,0 +1,82 @@
+/** Goal mode — ported from omp's goals/ module (state machine, accounting,
+ *  prompts, transition rules) to oma's architecture.
+ *
+ *  Design (omp-aligned): ONE persistent autonomous objective per session.
+ *  Completion is MODEL-DECLARED through the `goal` tool under strict prompt
+ *  disciplines (never redefine success smaller; audit repo state before
+ *  complete; budget exhaustion ≠ completion) — there is NO external
+ *  evaluator. Continuation is unconditional *of the model's text* while the
+ *  goal is active: after every settled turn the runtime injects a hidden
+ *  continuation steer, even past a terminal text answer. The one behavioural
+ *  backstop is a stall — turns that stop using tools at all pause the goal
+ *  rather than continuing forever. An interrupt PAUSES the goal (never drops);
+ *  token/time budgets are accounted per turn; crossing the budget flips the
+ *  goal to budget-limited and injects a wrap-up steer exactly once. State
+ *  transitions persist as session events and replay on resume. */
+export type GoalStatus = "active" | "paused" | "budget-limited" | "complete" | "dropped";
+export interface Goal {
+    id: string;
+    objective: string;
+    status: GoalStatus;
+    tokenBudget?: number;
+    tokensUsed: number;
+    timeUsedSeconds: number;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface GoalModeState {
+    /** Goal mode driving turns: true from create until complete/drop/pause. */
+    enabled: boolean;
+    mode: "active" | "exiting";
+    reason?: "completed";
+    goal: Goal;
+}
+export type GoalPromptKind = "active" | "continuation" | "budget-limit";
+/** omp's accounting formula (diverges from codex-rs): input + output +
+ *  cacheWrite, never cacheRead (reused prefix is not new work; cache writes
+ *  can bill 100K+ and must count). */
+export declare function goalTokenDelta(usage: {
+    inputTokens?: number;
+    outputTokens?: number;
+    cacheWriteTokens?: number;
+}): number;
+export declare function validateTokenBudget(tokenBudget: number | undefined): void;
+/** Statuses that keep accumulating tokens/time (active work states). */
+export declare function isAccountingStatus(goal: Goal): boolean;
+export declare function remainingTokens(goal: Goal): number | null;
+export declare function createGoal(objective: string, tokenBudget?: number): GoalModeState;
+/** ---- Transition rules (omp runtime semantics) ---- */
+export declare function canCreateGoal(state: GoalModeState | null): boolean;
+export declare function pauseGoal(state: GoalModeState): GoalModeState;
+export declare function resumeGoal(state: GoalModeState): GoalModeState;
+export declare function dropGoal(): GoalModeState | null;
+export declare function completeGoal(state: GoalModeState): GoalModeState;
+export declare function budgetLimitedGoal(state: GoalModeState): GoalModeState;
+/** Pure accrual: fold one turn's usage + wall clock into the goal,
+ *  regardless of status. The post-run path uses it through accountTurn
+ *  (live goals only); the complete-flush path uses it directly, because by
+ *  then the goal is already terminal but the final turn still counts. */
+export declare function accrueUsage(goal: Goal, usage: {
+    inputTokens?: number;
+    outputTokens?: number;
+    cacheWriteTokens?: number;
+}, wallSeconds: number): Goal;
+/** Account one settled turn's usage + wall clock for a LIVE goal. Returns
+ *  the next state and whether the budget was crossed THIS turn (the caller
+ *  steers once). */
+export declare function accountTurn(state: GoalModeState, usage: {
+    inputTokens?: number;
+    outputTokens?: number;
+    cacheWriteTokens?: number;
+}, wallSeconds: number): {
+    state: GoalModeState;
+    crossedBudget: boolean;
+};
+export declare function renderGoalPrompt(kind: GoalPromptKind, goal: Goal): string;
+/** The /guided-goal interview kickoff (omp guided-goal-interview.md): the
+ *  model interrogates the user until five elements are pinned, then calls
+ *  goal({op:"create"}). */
+export declare function renderInterviewPrompt(rough?: string): string;
+/** Surfaces with the complete tool result (omp completionBudgetReport). */
+export declare function completionBudgetReport(goal: Goal): string | null;
+//# sourceMappingURL=state.d.ts.map

package/dist/core/goals/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../src/core/goals/state.ts"],"names":[],"mappings":"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"}

package/dist/core/goals/state.js

@@ -0,0 +1,225 @@
+/** Goal mode — ported from omp's goals/ module (state machine, accounting,
+ *  prompts, transition rules) to oma's architecture.
+ *
+ *  Design (omp-aligned): ONE persistent autonomous objective per session.
+ *  Completion is MODEL-DECLARED through the `goal` tool under strict prompt
+ *  disciplines (never redefine success smaller; audit repo state before
+ *  complete; budget exhaustion ≠ completion) — there is NO external
+ *  evaluator. Continuation is unconditional *of the model's text* while the
+ *  goal is active: after every settled turn the runtime injects a hidden
+ *  continuation steer, even past a terminal text answer. The one behavioural
+ *  backstop is a stall — turns that stop using tools at all pause the goal
+ *  rather than continuing forever. An interrupt PAUSES the goal (never drops);
+ *  token/time budgets are accounted per turn; crossing the budget flips the
+ *  goal to budget-limited and injects a wrap-up steer exactly once. State
+ *  transitions persist as session events and replay on resume. */
+/** omp's accounting formula (diverges from codex-rs): input + output +
+ *  cacheWrite, never cacheRead (reused prefix is not new work; cache writes
+ *  can bill 100K+ and must count). */
+export function goalTokenDelta(usage) {
+    return (Math.max(0, usage.inputTokens ?? 0) +
+        Math.max(0, usage.outputTokens ?? 0) +
+        Math.max(0, usage.cacheWriteTokens ?? 0));
+}
+export function validateTokenBudget(tokenBudget) {
+    if (tokenBudget !== undefined && (!Number.isInteger(tokenBudget) || tokenBudget <= 0)) {
+        throw new Error("goal token_budget must be a positive integer when provided");
+    }
+}
+/** Statuses that keep accumulating tokens/time (active work states). */
+export function isAccountingStatus(goal) {
+    return goal.status === "active" || goal.status === "budget-limited";
+}
+export function remainingTokens(goal) {
+    if (goal.tokenBudget === undefined)
+        return null;
+    return Math.max(0, goal.tokenBudget - goal.tokensUsed);
+}
+export function createGoal(objective, tokenBudget) {
+    const trimmed = objective.trim();
+    if (!trimmed)
+        throw new Error("objective is required");
+    validateTokenBudget(tokenBudget);
+    const now = Date.now();
+    const goal = {
+        id: `goal-${now.toString(36)}-${Math.random().toString(36).slice(2, 8)}`,
+        objective: trimmed,
+        status: "active",
+        tokensUsed: 0,
+        timeUsedSeconds: 0,
+        createdAt: now,
+        updatedAt: now,
+    };
+    if (tokenBudget !== undefined)
+        goal.tokenBudget = tokenBudget;
+    return { enabled: true, mode: "active", goal };
+}
+/** ---- Transition rules (omp runtime semantics) ---- */
+export function canCreateGoal(state) {
+    if (!state)
+        return true;
+    return state.goal.status === "dropped" || state.goal.status === "complete";
+}
+export function pauseGoal(state) {
+    const goal = { ...state.goal };
+    if (goal.status === "active" || goal.status === "budget-limited")
+        goal.status = "paused";
+    goal.updatedAt = Date.now();
+    return { enabled: false, mode: "active", goal };
+}
+export function resumeGoal(state) {
+    if (state.goal.status === "complete")
+        throw new Error("goal is already complete");
+    const goal = { ...state.goal, status: "active", updatedAt: Date.now() };
+    return { enabled: true, mode: "active", goal };
+}
+export function dropGoal() {
+    return null;
+}
+export function completeGoal(state) {
+    if (state.goal.status === "complete")
+        throw new Error("goal is already complete");
+    if (state.goal.status === "dropped")
+        throw new Error("cannot complete a dropped goal");
+    const goal = { ...state.goal, status: "complete", updatedAt: Date.now() };
+    return { enabled: false, mode: "exiting", reason: "completed", goal };
+}
+export function budgetLimitedGoal(state) {
+    const goal = { ...state.goal, status: "budget-limited", updatedAt: Date.now() };
+    return { ...state, goal };
+}
+/** Pure accrual: fold one turn's usage + wall clock into the goal,
+ *  regardless of status. The post-run path uses it through accountTurn
+ *  (live goals only); the complete-flush path uses it directly, because by
+ *  then the goal is already terminal but the final turn still counts. */
+export function accrueUsage(goal, usage, wallSeconds) {
+    return {
+        ...goal,
+        tokensUsed: goal.tokensUsed + goalTokenDelta(usage),
+        timeUsedSeconds: Math.round(goal.timeUsedSeconds + wallSeconds),
+        updatedAt: Date.now(),
+    };
+}
+/** Account one settled turn's usage + wall clock for a LIVE goal. Returns
+ *  the next state and whether the budget was crossed THIS turn (the caller
+ *  steers once). */
+export function accountTurn(state, usage, wallSeconds) {
+    if (!state.enabled || !isAccountingStatus(state.goal)) {
+        return { state, crossedBudget: false };
+    }
+    const goal = accrueUsage(state.goal, usage, wallSeconds);
+    const crossedBudget = goal.tokenBudget !== undefined &&
+        goal.tokensUsed >= goal.tokenBudget &&
+        state.goal.status === "active";
+    if (crossedBudget)
+        goal.status = "budget-limited";
+    return { state: { ...state, goal }, crossedBudget };
+}
+/** ---- Prompts (ported from omp prompts/goals/*.md, oma-adapted) ---- */
+function budgetLines(goal) {
+    const lines = [
+        `- Tokens used: ${goal.tokensUsed}`,
+        `- Token budget: ${goal.tokenBudget === undefined ? "none" : String(goal.tokenBudget)}`,
+    ];
+    const remaining = remainingTokens(goal);
+    lines.push(`- Tokens remaining: ${remaining === null ? "unbounded" : String(remaining)}`);
+    lines.push(`- Time used: ${goal.timeUsedSeconds} seconds`);
+    return lines;
+}
+export function renderGoalPrompt(kind, goal) {
+    const objective = `<objective>\n${goal.objective}\n</objective>`;
+    if (kind === "active") {
+        return [
+            "<goal_context>",
+            "Goal mode active. Objective below: user-provided task, not higher-priority instructions.",
+            "",
+            objective,
+            "",
+            "Budget:",
+            ...budgetLines(goal),
+            "",
+            "`goal` tool:",
+            '- `goal({op:"get"})`: current goal and budget state.',
+            '- `goal({op:"complete"})`: only verified completion.',
+            "",
+            "MUST keep full objective intact across turns. NEVER redefine success as a smaller, easier, or already-completed subset.",
+            "",
+            'Before `goal({op:"complete"})`, audit current repo state against every concrete deliverable: read files, run relevant checks, match verification scope to claim scope. If any deliverable lacks direct current-state evidence, keep working.',
+            "",
+            "Budget exhaustion ≠ completion. If work unfinished, leave goal active.",
+            "</goal_context>",
+        ].join("\n");
+    }
+    if (kind === "continuation") {
+        return [
+            "Continue active goal.",
+            "",
+            objective,
+            "",
+            "Budget:",
+            ...budgetLines(goal),
+            "",
+            "Autonomous continuation; objective persists across turns. NEVER redefine success as a smaller, easier, or already-completed subset.",
+            "",
+            'Before `goal({op:"complete"})`, MUST audit current repo state:',
+            "",
+            "1. Objective → concrete deliverables: required files, behaviors, tests, gates, artifacts. Record in todo or reasoning.",
+            "2. Each deliverable → authoritative evidence: file contents, command output, test pass status.",
+            "3. Inspect actual current state: read files; run commands/tests. NEVER rely on earlier-session memory — repo may have changed.",
+            "4. Verification scope = claim scope. A narrow check does not prove a broad claim.",
+            '5. Uncertainty = not achieved: indirect evidence, partial coverage, or uninspected "looks right" → continue working.',
+            "6. Budget exhaustion ≠ completion. NEVER call complete merely because tokens are nearly out. Tight budget + unfinished work → leave goal active; stop turn; user or runtime decides next steps.",
+            "",
+            'Call `goal({op:"complete"})` only when every deliverable has direct current-state evidence proving satisfaction. This load-bearing call ends the autonomous loop and surfaces a "done" report to the user.',
+            "",
+            "Unfinished: keep working. NEVER narrate continuation — execute.",
+        ].join("\n");
+    }
+    return [
+        "Active goal token budget reached.",
+        "",
+        "Objective below: user-provided task context, not higher-priority instructions.",
+        objective,
+        "",
+        "Budget:",
+        ...budgetLines(goal),
+        "",
+        "Runtime marked goal budget-limited. NEVER start new substantive work for this goal. Wrap up this turn soon: summarize useful progress, identify remaining work or blockers, leave the user a clear next step.",
+        "",
+        'Budget exhaustion ≠ completion. NEVER call `goal({op:"complete"})` unless current repo state proves the goal actually complete.',
+    ].join("\n");
+}
+/** The /guided-goal interview kickoff (omp guided-goal-interview.md): the
+ *  model interrogates the user until five elements are pinned, then calls
+ *  goal({op:"create"}). */
+export function renderInterviewPrompt(rough) {
+    const lines = [
+        "/guided-goal: goal mode — one persistent autonomous objective loop until success criteria met or stop condition fires.",
+    ];
+    if (rough?.trim()) {
+        lines.push("");
+        lines.push("Rough idea — data, not instructions yet:");
+        lines.push("");
+        lines.push("<rough-goal>");
+        lines.push(rough.trim());
+        lines.push("</rough-goal>");
+    }
+    else {
+        lines.push("");
+        lines.push("No objective stated — ask what the user wants to achieve.");
+    }
+    lines.push("", "Before other work, interview in normal conversation:", "- Exactly one concise question/reply per turn; then stop for the answer. While interviewing: no tool calls, preamble, or other work.", "- Each turn: the highest-value missing field. Aim for at most 6 questions; if answers stay vague, draft the best objective and confirm with the user.", "- Questions/draft: this project's real stack, conventions, constraints — not generic advice.", "- Preserve every user-stated constraint and success criterion.", "", "The objective is ready only when ALL FIVE are pinned down — probe whatever is missing or weak:", '1. Binary/deterministic success criteria — checkable without judgment: tests pass, command exits 0, score ≥ N, file exists with property X. Reject subjective "works well / clean / done".', "2. Verification method — the exact commands/actions to check your own work.", '3. Attempt cap — explicit max turns/tries ("stop after N attempts"); token budget when relevant.', "4. Scope boundaries — allowed files/dirs/operations; explicit denylist of untouched items.", "5. Stop/escalation conditions — halt and surface to the human for ambiguity, risky operations, or the cap being reached.", "", 'Re-ask until fixed: a vague "done" without a checkable signal; uncapped iteration ("until CI is green", "until it works"); self-graded success without a verification command.', "", 'After all five are settled, call `goal` with op:"create", the final objective, and token_budget if the user gave one. The objective MUST embed the five elements in a compact, ordered form.');
+    return lines.join("\n");
+}
+/** Surfaces with the complete tool result (omp completionBudgetReport). */
+export function completionBudgetReport(goal) {
+    const parts = [];
+    if (goal.tokenBudget !== undefined) {
+        parts.push(`tokens used: ${goal.tokensUsed} of ${goal.tokenBudget}`);
+    }
+    if (goal.timeUsedSeconds > 0)
+        parts.push(`time used: ${goal.timeUsedSeconds} seconds`);
+    if (parts.length === 0)
+        return null;
+    return `Goal achieved. Report final budget usage to the user: ${parts.join("; ")}.`;
+}

package/dist/core/goals/tool.d.ts

@@ -0,0 +1,10 @@
+import type { Plugin, PluginTool } from "../runtime/plugin.js";
+import type { GoalRuntime } from "./runtime.js";
+/** The model-facing `goal` tool (omp goals/tools/goal-tool.ts port): five
+ *  ops over the session's GoalRuntime. Mounted ONLY while goal mode is live
+ *  (active goal or /guided-goal interview) — the tool table is per-run, so
+ *  the session decides by including this plugin. */
+export declare function createGoalTool(runtime: GoalRuntime): PluginTool;
+/** The plugin wrapper the TUI mounts for a goal-mode run. */
+export declare function createGoalPlugin(runtime: GoalRuntime): Plugin;
+//# sourceMappingURL=tool.d.ts.map

package/dist/core/goals/tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../../src/core/goals/tool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAC/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEhD;;;oDAGoD;AACpD,wBAAgB,cAAc,CAAC,OAAO,EAAE,WAAW,GAAG,UAAU,CA0D/D;AAmBD,6DAA6D;AAC7D,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CAE7D"}

package/dist/core/goals/tool.js

@@ -0,0 +1,87 @@
+/** The model-facing `goal` tool (omp goals/tools/goal-tool.ts port): five
+ *  ops over the session's GoalRuntime. Mounted ONLY while goal mode is live
+ *  (active goal or /guided-goal interview) — the tool table is per-run, so
+ *  the session decides by including this plugin. */
+export function createGoalTool(runtime) {
+    return {
+        name: "goal",
+        description: "Manage the session's persistent autonomous goal. op=create (objective, optional token_budget) starts goal mode; op=get reads state; op=complete declares VERIFIED completion (audit current repo state first — verification scope = claim scope; never redefine success as a smaller/easier/already-done subset; budget exhaustion is NOT completion); op=resume / op=drop manage lifecycle.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                op: { type: "string", description: "create | get | complete | resume | drop" },
+                objective: { type: "string", description: "Goal objective (op=create)" },
+                token_budget: {
+                    type: "number",
+                    description: "Positive integer token budget (op=create, optional)",
+                },
+            },
+            required: ["op"],
+        },
+        async execute(input) {
+            const args = input;
+            try {
+                switch (args.op) {
+                    case "create": {
+                        const created = runtime.create(args.objective ?? "", args.token_budget);
+                        return { content: JSON.stringify(toolResponse(runtime, created)) };
+                    }
+                    case "get": {
+                        if (!runtime.goal)
+                            return { content: "No active goal." };
+                        return { content: JSON.stringify(toolResponse(runtime)) };
+                    }
+                    case "complete": {
+                        if (!runtime.goal)
+                            return { content: "No active goal.", isError: true };
+                        runtime.complete();
+                        return {
+                            content: "Goal marked complete. The autonomous loop ends after this turn; report the achievement (and budget usage, if any) to the user in your final message.",
+                        };
+                    }
+                    case "resume": {
+                        if (!runtime.goal)
+                            return { content: "No active goal.", isError: true };
+                        runtime.resume();
+                        return { content: JSON.stringify(toolResponse(runtime)) };
+                    }
+                    case "drop": {
+                        if (!runtime.goal)
+                            return { content: "No active goal.", isError: true };
+                        runtime.drop();
+                        return { content: "Goal dropped. Stop goal-directed work." };
+                    }
+                    default:
+                        return { content: `Error: unknown op "${args.op ?? ""}"`, isError: true };
+                }
+            }
+            catch (err) {
+                return {
+                    content: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                    isError: true,
+                };
+            }
+        },
+    };
+}
+/** omp goal-tool.ts buildGoalToolResponse shape. */
+function toolResponse(runtime, state = runtime.state) {
+    const goal = state?.goal;
+    if (!goal)
+        return { goal: null };
+    return {
+        goal: {
+            id: goal.id,
+            objective: goal.objective,
+            status: goal.status,
+            tokensUsed: goal.tokensUsed,
+            tokenBudget: goal.tokenBudget ?? null,
+            remainingTokens: runtime.remainingTokens(),
+            timeUsedSeconds: goal.timeUsedSeconds,
+        },
+    };
+}
+/** The plugin wrapper the TUI mounts for a goal-mode run. */
+export function createGoalPlugin(runtime) {
+    return { name: "goal-mode", tools: [createGoalTool(runtime)] };
+}

package/dist/core/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAYA,YAAY,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAChF,YAAY,EACV,aAAa,EACb,iBAAiB,EACjB,aAAa,EACb,UAAU,EACV,iBAAiB,EACjB,UAAU,GACX,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,YAAY,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EACL,qBAAqB,EACrB,uBAAuB,EACvB,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,gBAAgB,GACjB,MAAM,+BAA+B,CAAC;AACvC,YAAY,EAAE,eAAe,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC/F,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAEzD,YAAY,EAAE,mBAAmB,EAAE,MAAM,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAChG,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAChF,YAAY,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAEjE,YAAY,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,YAAY,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEjD,OAAO,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAC;AAChF,YAAY,EACV,gBAAgB,EAChB,iBAAiB,EACjB,YAAY,GACb,MAAM,0BAA0B,CAAC;AAClC,YAAY,EACV,kBAAkB,EAClB,qBAAqB,EACrB,sBAAsB,EACtB,qBAAqB,EACrB,eAAe,EACf,YAAY,GACb,MAAM,yBAAyB,CAAC;AAEjC,YAAY,EAAE,QAAQ,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAaA,YAAY,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAChF,YAAY,EACV,aAAa,EACb,iBAAiB,EACjB,aAAa,EACb,UAAU,EACV,iBAAiB,EACjB,UAAU,GACX,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,YAAY,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EACL,qBAAqB,EACrB,uBAAuB,EACvB,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,gBAAgB,GACjB,MAAM,+BAA+B,CAAC;AACvC,YAAY,EAAE,eAAe,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC/F,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAEzD,YAAY,EAAE,mBAAmB,EAAE,MAAM,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAChG,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAChF,YAAY,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAEjE,YAAY,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,YAAY,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEjD,OAAO,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAC;AAChF,YAAY,EACV,gBAAgB,EAChB,iBAAiB,EACjB,YAAY,GACb,MAAM,0BAA0B,CAAC;AAClC,YAAY,EACV,kBAAkB,EAClB,qBAAqB,EACrB,sBAAsB,EACtB,qBAAqB,EACrB,eAAe,EACf,YAAY,GACb,MAAM,yBAAyB,CAAC;AAEjC,YAAY,EAAE,QAAQ,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC"}