@sorenllm/opencode-forge 0.2.0 → 0.2.2

package/README.md

@@ -8,7 +8,8 @@ OpenSpec spec workflows remain a third, separate lane.
 
 ```
 /plan fix login timeout   → read-only recon → plan_write (draft, writes denied)
-                           → present → plan_approve (user dialog = approval gate)
+                           → present, end turn → USER REVIEW (revise / discard / go-ahead)
+                           → plan_approve (user dialog = final gate) on explicit go-ahead
                            → execute task by task, plan_tick on each (timestamped audit)
                            → all ticked → per-criterion self-check → plan_close
                              (user dialog = completion gate) → done
@@ -58,9 +59,9 @@ opencode plugin github:ChengZiiii/opencode-forge --global
 
 Local development: add `"file:///<repo abs path>"` to the `plugin` array in
 your opencode config. Single-file install: copy `dist/index.js` to
-`~/.config/opencode/plugin/forge.js` **and manually copy `SKILL.md`** to
-`~/.config/opencode/skills/plan/SKILL.md` (the package has no installer
-script; that mode has no bundled skill otherwise).
+`~/.config/opencode/plugin/forge.js` — it is fully self-contained (the plan
+discipline rides inside the /plan command template; there is no separate
+skill file).
 
 Note: do not enable opencode's experimental plan mode
 (`OPENCODE_EXPERIMENTAL_PLAN_MODE`) together with forge — two plan mechanisms
@@ -77,7 +78,7 @@ the plugin never writes them):
     "forge": {
       "model": "provider/model",   // pick any model for forge
       "disable": true              // one-knob return to native: no forge,
-                                   // build/plan restored, no tools/commands/skill
+                                   // build/plan restored, no tools/commands
     }
   }
 }
@@ -108,7 +109,7 @@ What this plugin touches, exhaustively:
 | --- | --- | --- |
 | `<project>/.opencode/plan/*.md` | plan files | user data — kept forever, uninstall never deletes |
 | `<project>/.opencode/goal/*.md` | goal files (contract, Check Log, Turn Ledger) | user data — kept forever, uninstall never deletes |
-| merged config object (RAM only) | forge agent, native build/plan `disable`, `skills.paths` entry, `command.plan`, `command.goal`, goal permission keys | vanishes when the plugin is removed; nothing is written to disk |
+| merged config object (RAM only) | forge agent, native build/plan `disable`, `command.plan`, `command.goal`, goal permission keys | vanishes when the plugin is removed; nothing is written to disk |
 | `~/.cache/opencode/packages/...` | installed package copy | written by the `opencode plugin` installer, not the plugin |
 | `~/.config/opencode/opencode.json` | `plugin` array entry | written by the installer |
 
@@ -208,11 +209,12 @@ bun run bundle        # rebuild self-contained dist/index.js (committed)
 ```
 
 Architecture: `plugin.ts` (dual entry — v1 `server` full-featured + v2
-`setup` defensive forward-compat) + `src/plan-file.ts` / `src/goal-file.ts`
+`setup` defensive forward-compat; the /plan and /goal command templates each
+carry their own full discipline, hermes-style: the entry turn is the
+rulebook) + `src/plan-file.ts` / `src/goal-file.ts`
 (pure document cores, unit-tested, no opencode imports) + `src/run-check.ts`
 (shell/file-contract runner with tree-kill timeouts and a workspace path
-guard) + `SKILL.md` (planning discipline, discovered via
-`config.skills.paths`). Behavioral changes go through the
+guard). Behavioral changes go through the
 OpenSpec workflow in `openspec/` — see AGENTS.md. Common pitfalls live in
 `../opencode-plugin-dev-pitfalls.md`.
 

package/dist/index.js

@@ -12335,8 +12335,7 @@ function tool(input) {
 tool.schema = exports_external;
 // plugin.ts
 import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { dirname, join as join2, relative } from "node:path";
+import { join as join2, relative } from "node:path";
 import { tmpdir } from "node:os";
 
 // src/plan-file.ts
@@ -12721,7 +12720,7 @@ function goalFileName(date5, slug, existingNames = []) {
   return name;
 }
 function atomicWrite(file2, text) {
-  const tmp = `${file2}.tmp`;
+  const tmp = `${file2}.${process.pid}-${Math.random().toString(36).slice(2, 6)}.tmp`;
   writeFileSync(tmp, text);
   renameSync(tmp, file2);
 }
@@ -12772,6 +12771,8 @@ function frontmatterBlock2(meta) {
     `updated: ${meta.updated}`,
     `revision: ${meta.revision}`
   ];
+  if (meta.armedAt)
+    lines.push(`armed_at: ${meta.armedAt}`);
   if (meta.session)
     lines.push(`session: ${meta.session}`);
   lines.push(`max_turns: ${meta.maxTurns}`, `turns_used: ${meta.turnsUsed}`, `max_minutes: ${meta.maxMinutes}`);
@@ -12798,6 +12799,7 @@ function renderGoal(input, meta) {
       maxTurns: input.maxTurns ?? DEFAULT_MAX_TURNS,
       turnsUsed: meta.turnsUsed ?? 0,
       maxMinutes: input.maxMinutes ?? DEFAULT_MAX_MINUTES,
+      ...meta.armedAt ? { armedAt: meta.armedAt } : {},
       ...meta.status === "paused" && meta.stopReason ? { stopReason: meta.stopReason } : {}
     }),
     "## Goal",
@@ -12940,6 +12942,7 @@ function parseGoal(text) {
   return {
     status,
     created: fm.created ?? "",
+    armedAt: fm.armed_at ?? "",
     updated: fm.updated ?? "",
     revision: Math.max(1, num(fm.revision, 1)),
     session: fm.session ?? "",
@@ -12992,6 +12995,7 @@ function transitionGoal(text, to, now, opts = {}) {
     if (!opts.session)
       throw new GoalError("Arming/resuming requires the owning session id");
     next = setFm(next, "session", opts.session);
+    next = setFm(next, "armed_at", now);
     next = next.replace(/^stop_reason:.*$\r?\n?/m, "");
   }
   return setUpdated2(next, now);
@@ -13010,7 +13014,7 @@ function bumpBudget(text, addTurns, now) {
 function budgetState(doc2) {
   if (doc2.turnsUsed >= doc2.maxTurns)
     return "budget-turns";
-  const start = Date.parse(doc2.created);
+  const start = Date.parse(doc2.armedAt || doc2.created);
   if (Number.isFinite(start) && Date.now() - start > doc2.maxMinutes * 60000)
     return "budget-time";
   return "ok";
@@ -13076,12 +13080,12 @@ function appendLedger(text, entry, now) {
 function carryHistory(newText, oldDoc) {
   let out = newText;
   if (oldDoc.log.length > 0) {
-    out = out.replace("(no checks recorded yet)", oldDoc.log.join(`
+    out = out.replace("(no checks recorded yet)", () => oldDoc.log.join(`
 `));
   }
   if (oldDoc.ledger.length > 0) {
     const lines = oldDoc.ledger.map((e) => `- turn ${e.turn} rev${e.revision} ${e.at} activity=${e.activity ? "yes" : "no"} (writes=${e.writes} checks=${e.checks})`);
-    out = out.replace("(no continuation turns yet)", lines.join(`
+    out = out.replace("(no continuation turns yet)", () => lines.join(`
 `));
   }
   return out;
@@ -13154,11 +13158,14 @@ var defaultShellRunner = (cmd, opts) => new Promise((resolveRun) => {
     timedOut = true;
     killTree();
   }, opts.timeoutMs);
+  const failsafe = setTimeout(() => settle({ code: null, output, timedOut: true, spawnError: "timeout settle fallback" }), opts.timeoutMs + 30000);
+  failsafe.unref?.();
   const settle = (r) => {
     if (settled)
       return;
     settled = true;
     clearTimeout(timer);
+    clearTimeout(failsafe);
     resolveRun(r);
   };
   child.stdout?.on("data", (d) => {
@@ -13171,7 +13178,6 @@ var defaultShellRunner = (cmd, opts) => new Promise((resolveRun) => {
   });
   child.on("error", (err) => settle({ code: null, output, timedOut, spawnError: err.message }));
   child.on("close", (code) => settle({ code, output, timedOut }));
-  setTimeout(() => settle({ code: null, output, timedOut: true, spawnError: "timeout settle fallback" }), opts.timeoutMs + 30000);
 });
 var shellRunner = defaultShellRunner;
 function truncateOutput(output) {
@@ -13244,29 +13250,10 @@ function formatOutcomes(outcomes) {
 }
 
 // plugin.ts
-var bundleDir = dirname(fileURLToPath(import.meta.url));
-var candidateDirs = [bundleDir, join2(bundleDir, "..")];
-var dataDir = candidateDirs.find((d) => existsSync(join2(d, "SKILL.md"))) ?? bundleDir;
 var FORGE_AGENT = "forge";
-var FORGE_PROMPT = `You are forge — the single general-purpose coding agent. You handle every task directly: exploration, planning, implementation, and verification. There is no agent switching; phases change through commands (/plan, /goal) and tools.
+var FORGE_PROMPT = `You are forge — the single general-purpose coding agent. You handle every task directly: exploration, planning, implementation, and verification. There is no agent switching.
 
-Plan discipline (the tooling enforces the hard parts; you supply the judgment):
-- When the user invokes /plan with a goal, or asks to plan first, load the plan skill and follow it: read-only reconnaissance, clarifying questions when the goal is ambiguous, then plan_write. It creates .opencode/plan/<date>-<slug>.md with status draft.
-- While the session's plan is in draft, every write tool is denied at the permission layer. Do not attempt write/edit/bash/task during planning; do not ask the user to bypass it. The only exits are plan_approve and /plan discard.
-- After plan_write, present the goal, chosen approach, and numbered task list briefly, then call plan_approve. The user approves it in a confirmation dialog — that dialog is the approval gate.
-- After approval, execute tasks one by one and call plan_tick with the task number immediately after each completion. Never batch ticks at the end; never tick before the work is actually done.
-- When all tasks are ticked, self-check every acceptance criterion with concrete evidence, then call plan_close with a per-criterion pass/evidence array. The user confirms closure in a dialog.
-- If the system prompt carries a [forge:plan-notice] line and the user has not mentioned the plan, relay its path and progress in one short line at the start of your reply.
-- Work that is expected to span sessions, touch many files over days, or need multi-round requirement review belongs to a spec workflow (e.g. OpenSpec), not a plan. Say so once and let the user choose; if they still want a plan, plan it.
-
-Goal discipline (autonomous, host-verified execution; orthogonal to plans and spec workflows — a goal never reads plan state and plan state is never goal evidence):
-- /goal "<objective>" drafts a goal contract: goal, numbered success criteria, numbered verification items (shell commands the plugin runs itself, and file contracts file::text), constraints, non-goals, budgets. Show the verification items verbatim before arming. goal_write with arm=true presents a confirmation dialog — the user's Allow arms the autonomous loop. arm=false (/goal add) only queues an inert goal.
-- When a [forge:goal-continue] brief arrives, keep working the success criteria within the stated constraints. The plugin continues the session on idle until the goal completes, pauses, or hits its turn/minute budget.
-- goal_check runs the verification items on the host and appends results to the goal's Check Log — use it whenever you believe the criteria may hold. goal_complete re-runs EVERY item itself (fail-closed: any failing item refuses completion) and additionally requires a per-criterion attestation with concrete evidence, then a user confirmation dialog.
-- If you are genuinely blocked, call goal_pause with the blocker text — do not spin. When the goal is paused and the user clearly asks to continue (e.g. "continue", "resume"), call goal_resume; the dialog re-arms the loop. Ordinary chat never reactivates a goal.
-- Never claim the goal is complete without passing goal_complete. Never edit the goal file by hand; revise the contract through goal_write (which bumps the revision and invalidates earlier evidence).
-
-Outside planning you are a normal full-capability coding agent.`;
+Workflow modes are strictly user-initiated. Never enter plan or goal mode — and never call a plan_* or goal_* tool — unless the user ran /plan or /goal, unmistakably asked for that mode (e.g. "plan first", "set a goal"), or the session already carries a [forge:plan-notice] / [forge:goal-notice] for a mode they started. Ordinary task requests are normal work. Mode-specific rules arrive with those commands and notices; when a notice is present, follow it.`;
 var PLAN_COMMAND_TEMPLATE = [
   '(forge plan harness routing. Argument: "$ARGUMENTS")',
   "",
@@ -13277,7 +13264,19 @@ var PLAN_COMMAND_TEMPLATE = [
   "- Argument empty: for every non-terminal plan (status draft or approved) in the directory above, read its frontmatter and task checkboxes, then report to the user: path, status, progress (x/y ticked). Ask whether to resume one or start something new.",
   '- Argument "resume": pick the most recently updated non-terminal plan, summarize its remaining unticked tasks to the user in one short list, then continue executing it — tick each task the moment it is done (plan_tick). If none exists, say so.',
   '- Argument "discard": call the plan_discard tool, then tell the user the plan was abandoned and writes are restored.',
-  "- Any other argument: treat it as the task goal. Load the plan skill (skill tool), then follow its planning discipline for this goal.",
+  "- Any other argument: treat it as the task goal — you are now in planning mode for this goal. Follow the plan discipline below end to end.",
+  "",
+  "## Plan discipline",
+  "",
+  "Plans are short-horizon, single-task-goal documents (.opencode/plan/<date>-<slug>.md). The harness enforces the hard parts (draft write-ban, approval/close dialogs); you supply the engineering judgment. Never edit or create plan files by hand — every change goes through the plan_* tools.",
+  "",
+  "1. Reconnaissance and alignment (read-only): explore with read/grep/glob only — all write tools, bash, and subagents are DENIED while a draft exists; do not attempt them, do not ask the user to bypass. Gather concrete evidence with file:line references (verified findings, not guesses). If the goal is ambiguous or leaves meaningful choices open (scope, approach, acceptance), settle them with the user FIRST — 1-3 focused questions — and only write the draft once the shape is agreed; never plan against assumptions the user could settle in one line.",
+  "2. Draft (plan_write): call plan_write with structured fields; the tool renders and validates the fixed sections, so a malformed plan cannot exist. Quality bar: goal = one line, the outcome not the activity; context = verified findings with file:line evidence, including what you ruled out and why; approach = the chosen approach AND at least one rejected alternative with the reason (a plan with no considered alternative is a guess); tasks = 3-8 concrete, independently verifiable steps, each doable in one sitting ('improve the code' is invalid; 'extract the timeout constant into config.ts and default it to 3000' is valid); risks = what could break, blast radius, rollback path; acceptance = criteria verifiable by a command, a file, or an observable behavior (vague criteria will fail the close); nonGoals = explicit out-of-scope items. To revise after feedback, call plan_write again — while in draft it overwrites the same file.",
+  `3. User review, then approval (plan_approve): after plan_write, present the plan in chat — goal, chosen approach with one line why, the numbered task list, the acceptance criteria — then STOP: end your turn and wait. The user owns the review, at their own pace: feedback → revise with plan_write, re-present, and wait again; rejection → /plan discard (or re-plan together); explicit go-ahead (e.g. "execute", "批准", "looks good") → call plan_approve — its confirmation dialog is the final hard gate, and the user's Allow starts execution. Never call plan_approve in the same turn that presents a draft, and never implement before approval succeeds.`,
+  "4. Execution (tick as you go): work tasks in order; call plan_tick with the task number immediately after EACH task's work is actually done — never batch ticks, never tick ahead of reality (tick timestamps are an audit trail). If the plan turns out wrong mid-execution, do not silently improvise: tell the user what changed and either finish the affected task or ask about revising (/plan with the same goal re-enters planning).",
+  "5. Completion (plan_close): when all tasks are ticked, self-check EVERY acceptance criterion with concrete evidence (file:line, command output, test result), then call plan_close with one check per criterion, pass/fail honest — a failing check refuses the close, and that is the design working, not an inconvenience. The user confirms closure in a dialog.",
+  "",
+  "Boundaries: /plan discard abandons the plan (terminal, file kept as history, writes restored); /plan resume continues an unfinished plan from its remaining tasks. Work expected to span multiple sessions or days of multi-file change is spec work (e.g. OpenSpec), not plan work — say so once and let the user choose.",
   ""
 ].join(`
 `);
@@ -13295,6 +13294,8 @@ var GOAL_COMMAND_TEMPLATE = [
   '- Argument "discard" (also "stop"/"cancel"/"off"): call the goal_discard tool. The user confirms in a dialog.',
   '- Argument starting with "add " (or the user clearly wants to queue without arming): create a NEW contract from the rest of the argument and call goal_write with arm=false — never revise an existing goal for an add, never omit arm. It becomes a queued, inert goal (no dialog).',
   '- Any other argument: treat it as a goal statement. Extract contract markers into the structured goal_write fields: --check "cmd" becomes a shell verification item, --contains "file::text" a file-contract item, --success "..." an extra success criterion, --constraint "..." goes into constraints, --non-goal "..." into nonGoals, --max-turns N and --max-minutes N set budgets. Draft a complete contract (goal, criteria, checks, constraints, non-goals), SHOW the verification items verbatim to the user, then call goal_write with arm=true — a confirmation dialog arms the autonomous loop. If this session already has a live goal, say so and offer revise/queue/discard instead.',
+  "",
+  "Goal files are host-managed: never edit or create anything under .opencode/goal/ by hand — contract changes go through goal_write (each revision bump invalidates evidence collected under earlier revisions), state changes through the goal_* tools. Likewise never enter the goal loop or call any goal_* tool unless the user ran /goal or explicitly asked for a goal loop.",
   ""
 ].join(`
 `);
@@ -13360,7 +13361,7 @@ function relFrom(worktree, path) {
   return rel && !rel.startsWith("..") ? rel.replaceAll("\\", "/") : path;
 }
 var planWriteTool = tool({
-  description: "Create or revise the session's plan (structured planning document, written to .opencode/plan/<date>-<slug>.md, status draft). The only sanctioned write while planning. Takes structured fields; the tool renders and validates the fixed sections — you cannot produce a malformed plan file.",
+  description: "Only used inside the /plan flow (the user ran /plan, asked to plan first, or a [forge:plan-notice] is present) — never self-initiate planning. Create or revise the session's plan (structured planning document, written to .opencode/plan/<date>-<slug>.md, status draft). The only sanctioned write while planning. Takes structured fields; the tool renders and validates the fixed sections — you cannot produce a malformed plan file.",
   args: {
     goal: tool.schema.string().describe("One-line task goal (used for the filename slug and the Goal section)"),
     context: tool.schema.string().describe("Context Findings: what the reconnaissance actually found, with file:line evidence references"),
@@ -13433,7 +13434,7 @@ async function gate(ask, permission, title) {
   await ask({ permission, patterns: ["*"], always: [], metadata: { title } });
 }
 var planApproveTool = tool({
-  description: "Ask the user to approve the session's draft plan (draft -> approved). The permission layer pins this call to a confirmation dialog — the user's Allow IS the approval. After approval the draft-phase write ban is lifted. Optionally pass a one-line summary of what changed since the last revision.",
+  description: "Approve the session's draft plan (draft -> approved). Call it ONLY after presenting the plan and receiving the user's explicit go-ahead in chat — never in the same turn that presents the draft. The permission layer pins this call to a confirmation dialog — the user's Allow is the final hard gate and lifts the draft-phase write ban. Optionally pass a one-line summary of what changed since the last revision.",
   args: {
     summary: tool.schema.string().optional().describe("One-line summary presented alongside the approval request")
   },
@@ -13534,8 +13535,11 @@ function resolveLiveGoal(state) {
 function coerceChecks(rows) {
   const items = [];
   for (const c of rows) {
+    if ([c.shell, c.containsFile, c.containsText].some((v) => typeof v === "string" && v.includes("`"))) {
+      throw new GoalError("Verification items must not contain backticks (they break the goal file format)");
+    }
     if (typeof c.shell === "string" && c.shell.trim()) {
-      items.push({ kind: "shell", cmd: c.shell.trim(), ...c.timeoutSec ? { timeoutSec: c.timeoutSec } : {} });
+      items.push({ kind: "shell", cmd: c.shell.trim(), ...c.timeoutSec ? { timeoutSec: Math.min(Math.max(1, c.timeoutSec), 600) } : {} });
     } else if (typeof c.containsFile === "string" && c.containsFile.trim() && typeof c.containsText === "string" && c.containsText.trim()) {
       items.push({ kind: "contains", file: c.containsFile.trim(), text: c.containsText });
     } else {
@@ -13545,7 +13549,7 @@ function coerceChecks(rows) {
   return items;
 }
 var goalWriteTool = tool({
-  description: "Create or revise the session's goal contract (written to .opencode/goal/<date>-<slug>.md). Creating with arm=true arms the autonomous continuation loop — a user confirmation dialog IS the arm action; arm=false only queues an inert goal (/goal add). While this session already has a live goal, creating another is refused — pass revise=true to edit the current contract instead (bumps the revision; evidence from earlier revisions no longer counts; budgets carry over unless explicitly changed). Orthogonal to plans: never reads plan state.",
+  description: "Only used inside the /goal flow (the user ran /goal or explicitly asked for a goal loop) — never self-initiate. Create or revise the session's goal contract (written to .opencode/goal/<date>-<slug>.md). Creating with arm=true arms the autonomous continuation loop — a user confirmation dialog IS the arm action; arm=false only queues an inert goal (/goal add). While this session already has a live goal, creating another is refused — pass revise=true to edit the current contract instead (bumps the revision; evidence from earlier revisions no longer counts; budgets carry over unless explicitly changed). Orthogonal to plans: never reads plan state.",
   args: {
     goal: tool.schema.string().describe("One-line goal statement (the semantic completion requirement)"),
     criteria: tool.schema.array(tool.schema.string()).describe("Success Criteria: numbered, verifiable outcomes"),
@@ -13591,6 +13595,7 @@ var goalWriteTool = tool({
         revision: existing.doc.revision + 1,
         ...existing.doc.session ? { session: existing.doc.session } : {},
         turnsUsed: existing.doc.turnsUsed,
+        ...existing.doc.armedAt ? { armedAt: existing.doc.armedAt } : {},
         ...existing.doc.status === "paused" && existing.doc.stopReason ? { stopReason: existing.doc.stopReason } : {}
       }), existing.doc);
       atomicWrite(existing.path, text2);
@@ -13620,7 +13625,7 @@ var goalWriteTool = tool({
     const text = renderGoal(input, {
       now,
       status: arm ? "active" : "queued",
-      ...arm ? { session: context.sessionID } : {}
+      ...arm ? { session: context.sessionID, armedAt: now } : {}
     });
     atomicWrite(path, text);
     state.goalPath = path;
@@ -13887,49 +13892,61 @@ async function autoPauseGoal(client, state, goal, reason, wrapup) {
   }
 }
 async function continueIfEligible(client, sessionID) {
-  if (continuationInFlight.has(sessionID))
-    return;
-  let state = sessions.get(sessionID);
-  if (!state) {
-    try {
-      const info = await client.session.get({ path: { id: sessionID } });
-      const wt = effectiveWorktree(info?.worktree, info?.directory);
-      if (!wt) {
-        goalProbe(`skip: no worktree for lazy seed session=${sessionID}`);
-        return;
-      }
-      state = ensureSession(sessionID, wt);
-      goalProbe(`lazy-seeded session=${sessionID} worktree=${wt}`);
-    } catch (err) {
-      goalProbe(`lazy-seed failed session=${sessionID} err=${String(err)}`);
-      return;
-    }
-  }
-  const goal = resolveLiveGoal(state);
-  if (!goal || goal.doc.status !== "active") {
-    goalProbe(`skip: no live active goal session=${sessionID}`);
+  if (forgeDisabled) {
+    goalProbe(`skip: forge disabled session=${sessionID}`);
     return;
   }
-  if (goal.doc.session && goal.doc.session !== sessionID) {
-    goalProbe(`skip: not goal owner session=${sessionID} owner=${goal.doc.session}`);
+  if (continuationInFlight.has(sessionID))
     return;
-  }
   continuationInFlight.add(sessionID);
   try {
+    let state = sessions.get(sessionID);
+    if (!state) {
+      try {
+        const info = await client.session.get({ path: { id: sessionID } });
+        const wt = effectiveWorktree(info?.worktree, info?.directory);
+        if (!wt) {
+          goalProbe(`skip: no worktree for lazy seed session=${sessionID}`);
+          return;
+        }
+        state = ensureSession(sessionID, wt);
+        goalProbe(`lazy-seeded session=${sessionID} worktree=${wt}`);
+      } catch (err) {
+        goalProbe(`lazy-seed failed session=${sessionID} err=${String(err)}`);
+        return;
+      }
+    }
+    let accountedContinuationTurn = false;
+    let turnHadActivity = false;
     if (pendingContinuationTurn.has(sessionID)) {
+      accountedContinuationTurn = true;
       pendingContinuationTurn.delete(sessionID);
       const act = turnActivity.get(sessionID);
-      const hadActivity = !!act && (act.writes > 0 || act.checks > 0);
+      turnHadActivity = !!act && (act.writes > 0 || act.checks > 0);
       turnActivity.set(sessionID, { writes: 0, checks: 0 });
-      try {
-        const fresh = parseGoalLoose(readFileSync2(goal.path, "utf8"));
-        if (fresh && fresh.turnsUsed > 0) {
-          atomicWrite(goal.path, appendLedger(readFileSync2(goal.path, "utf8"), { turn: fresh.turnsUsed, revision: fresh.revision, at: nowIso(), activity: hadActivity, writes: act?.writes ?? 0, checks: act?.checks ?? 0 }, nowIso()));
+      const ledgerPath = state.goalPath;
+      if (ledgerPath && existsSync(ledgerPath)) {
+        try {
+          const fresh = parseGoalLoose(readFileSync2(ledgerPath, "utf8"));
+          if (fresh && fresh.turnsUsed > 0) {
+            atomicWrite(ledgerPath, appendLedger(readFileSync2(ledgerPath, "utf8"), { turn: fresh.turnsUsed, revision: fresh.revision, at: nowIso(), activity: turnHadActivity, writes: act?.writes ?? 0, checks: act?.checks ?? 0 }, nowIso()));
+          }
+        } catch (err) {
+          goalProbe(`ledger append failed session=${sessionID} err=${String(err)}`);
         }
-      } catch (err) {
-        goalProbe(`ledger append failed session=${sessionID} err=${String(err)}`);
       }
-      if (hadActivity) {
+    }
+    const goal = resolveLiveGoal(state);
+    if (!goal || goal.doc.status !== "active") {
+      goalProbe(`skip: no live active goal session=${sessionID}`);
+      return;
+    }
+    if (!goal.doc.session || goal.doc.session !== sessionID) {
+      goalProbe(`skip: not goal owner session=${sessionID} owner=${goal.doc.session || "(none)"}`);
+      return;
+    }
+    if (accountedContinuationTurn) {
+      if (turnHadActivity) {
         noProgressStreak.delete(sessionID);
       } else {
         const n = (noProgressStreak.get(sessionID) ?? 0) + 1;
@@ -13972,6 +13989,7 @@ async function continueIfEligible(client, sessionID) {
       transportFails.delete(sessionID);
       pendingContinuationTurn.add(sessionID);
       turnActivity.set(sessionID, { writes: 0, checks: 0 });
+      state.goalPath = goal.path;
       atomicWrite(goal.path, incTurns(readFileSync2(goal.path, "utf8"), nowIso()));
       goalProbe(`continued session=${sessionID} turn=${goal.doc.turnsUsed + 1}/${goal.doc.maxTurns}`);
     } catch (err) {
@@ -13989,6 +14007,8 @@ async function continueIfEligible(client, sessionID) {
   }
 }
 function scheduleIdleContinuation(client, sessionID) {
+  if (forgeDisabled)
+    return;
   const existing = idleTimers.get(sessionID);
   if (existing)
     clearTimeout(existing);
@@ -14021,12 +14041,6 @@ var server = async (input) => {
         mode: existing?.mode ?? "primary",
         prompt: existing?.prompt ?? FORGE_PROMPT
       };
-      const cfgAny = cfg;
-      cfgAny.skills ??= {};
-      cfgAny.skills.paths ??= [];
-      if (!cfgAny.skills.paths.includes(dataDir)) {
-        cfgAny.skills.paths.push(dataDir);
-      }
       cfg.command ??= {};
       cfg.command["plan"] ??= {
         template: PLAN_COMMAND_TEMPLATE,
@@ -14121,9 +14135,11 @@ var server = async (input) => {
       if (active) {
         const p = progressOf(active.doc);
         const rel = relFrom(state.worktree, active.path);
-        const rule = active.doc.status === "draft" ? "while in draft, write operations are denied at the tool layer; present the summary then call plan_approve for approval, or /plan discard to abandon" : "call plan_tick immediately after each completed task; when all are done, self-check every acceptance criterion and call plan_close";
+        const rule = active.doc.status === "draft" ? "while in draft, write operations are denied at the tool layer; present the plan then end your turn to await the user's review — on feedback revise via plan_write and re-present; call plan_approve only after the user explicitly approves in chat (their confirmation dialog is the final gate); /plan discard to abandon" : "call plan_tick immediately after each completed task; when all are done, self-check every acceptance criterion and call plan_close";
         output.system.push(`[forge:plan-notice] This session is bound to a plan: ${rel} (status: ${active.doc.status}, ${p.done}/${p.total} tasks done). Rule: ${rule}. If the user has not mentioned this plan yet, relay its path and progress to them in one short line at the start of your reply.`);
       }
+      if (forgeDisabled)
+        return;
       const goal = resolveLiveGoal(state);
       if (goal) {
         const rel = relFrom(state.worktree, goal.path);
@@ -14133,6 +14149,8 @@ var server = async (input) => {
       }
     },
     "experimental.session.compacting": async (input2, output) => {
+      if (forgeDisabled)
+        return;
       if (!input2.sessionID)
         return;
       const state = sessions.get(input2.sessionID);
@@ -14148,13 +14166,15 @@ ${d.criteria.map((c, i) => `${i + 1}. ${c}`).join(`
 Post-compaction turns must keep following this goal and its constraints.`);
     },
     "experimental.compaction.autocontinue": async (input2, output) => {
+      if (forgeDisabled)
+        return;
       if (!input2.sessionID)
         return;
       const state = sessions.get(input2.sessionID);
       if (!state)
         return;
       const goal = resolveLiveGoal(state);
-      if (goal && goal.doc.status === "active")
+      if (goal)
         output.enabled = false;
     }
   };
@@ -14173,13 +14193,6 @@ async function v2Setup(ctx) {
       });
     });
   }
-  if (typeof ctx.skill?.transform === "function") {
-    await ctx.skill.transform(async (draft) => {
-      if (typeof draft.source !== "function")
-        return;
-      draft.source({ type: "directory", path: dataDir });
-    });
-  }
 }
 var plugin_default = { id: "forge", server, setup: v2Setup };
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sorenllm/opencode-forge",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Single general-purpose forge agent for opencode with two orthogonal harnesses: a plan harness (file-backed plans in .opencode/plan/, approve/close confirmation gates, tick discipline, hard write-ban while planning) and a goal harness (autonomous, host-verified objectives in .opencode/goal/ — idle continuation under turn/minute budgets, shell + file-contract checks re-run by the plugin at the completion gate, no-progress/transport/budget auto-pause, queueing).",
   "type": "module",
   "main": "./dist/index.js",
@@ -14,7 +14,6 @@
   },
   "files": [
     "dist",
-    "SKILL.md",
     "README.md"
   ],
   "scripts": {
@@ -29,7 +28,7 @@
     "planning",
     "workflow",
     "single-agent",
-    "skill"
+    "goal"
   ],
   "license": "MIT",
   "author": "chengsongren",

package/SKILL.md

@@ -1,91 +0,0 @@
----
-name: plan
-description: >-
-  The plan discipline for the forge agent. You **MUST** load this skill when
-  the /plan command routes a task goal to you, OR the user asks to "plan
-  first", "make a plan", "think before coding" before implementation. It
-  governs the whole plan lifecycle: read-only reconnaissance, clarifying
-  questions, plan_write (structured, tool-rendered), user-approval via
-  plan_approve, tick-as-you-go execution via plan_tick, per-criterion
-  self-check at plan_close, and the OpenSpec boundary for long-horizon work.
-  Do NOT load it for direct implementation requests with no planning intent.
----
-
-# Plan Discipline (forge)
-
-Plans are short-horizon, single-task-goal documents on disk
-(`.opencode/plan/<date>-<slug>.md`). The harness (tools + permission layer)
-enforces the hard parts; you supply the engineering judgment.
-
-## Phase 1 — Reconnaissance (read-only)
-
-- Explore with read/grep/glob only. **All write tools, bash, and task
-  (subagents) are denied while a draft exists** — do not attempt them, do not
-  ask the user to bypass.
-- Gather concrete evidence with `file:line` references; the plan's Context
-  Findings section must contain findings you actually verified, not guesses.
-- If the goal is ambiguous on scope, behavior, or acceptance — ask the user
-  1-3 focused questions FIRST. Do not plan against assumptions the user could
-  settle in one line.
-
-## Phase 2 — Write the plan (plan_write)
-
-Call `plan_write` with structured fields; the tool renders and validates the
-fixed sections (Goal / Non-Goals / Context Findings / Approach and
-Alternatives / Task List / Risks / Acceptance Criteria), so a malformed plan
-cannot exist.
-
-Quality bar for each field:
-
-- **goal**: one line, the outcome — not the activity.
-- **context**: verified findings with `file:line` evidence; include what you
-  ruled out and why.
-- **approach**: the chosen approach AND at least one rejected alternative
-  with the reason. A plan with no considered alternative is a guess.
-- **tasks**: 3-8 concrete, independently verifiable steps, each doable in one
-  sitting. A task like "improve the code" is invalid; "extract timeout
-  constant into config.ts and default it to 3000" is valid.
-- **risks**: what could break, blast radius, rollback path.
-- **acceptance**: criteria you can verify with a command, a file, or an
-  observable behavior. Vague criteria will fail the plan_close self-check.
-- **nonGoals**: explicit out-of-scope items (what the user might expect but
-  will NOT get).
-
-Revising: calling `plan_write` again while still in draft overwrites the same
-file. Do this after user feedback instead of hand-editing.
-
-## Phase 3 — Approval gate (plan_approve)
-
-Present to the user, briefly: goal, chosen approach (one line why), the
-numbered task list, and the acceptance criteria. Then call `plan_approve`.
-The user confirms in a dialog — that confirmation IS the approval. If they
-object, revise with `plan_write` and present again. Never proceed to
-implementation before approval succeeds.
-
-## Phase 4 — Execution (tick as you go)
-
-- Execute tasks in order; after EACH task's work is actually done, call
-  `plan_tick` with its number immediately. Never batch ticks; never tick
-  ahead of reality — the tick timestamp is an audit trail.
-- If mid-execution you discover the plan is wrong, do not silently improvise:
-  tell the user what changed and either finish the affected task anyway or
-  ask whether to revise (/plan with the same goal re-enters planning).
-
-## Phase 5 — Completion gate (plan_close)
-
-When all tasks are ticked: self-check EVERY acceptance criterion with
-concrete evidence (`file:line`, command output, test result). Call
-`plan_close` with one check per criterion, `pass` honest — a ✗ fails the
-close and that is the design working, not an inconvenience. The user
-confirms closure in a dialog.
-
-## Boundaries
-
-- **Abandon**: user cancels → `/plan discard` (or plan_discard). Terminal,
-  file kept as history, writes restored.
-- **Resume**: new session with unfinished plan → the system notice carries
-  the path; `/plan resume` continues from the remaining tasks.
-- **Spec-workflow boundary**: work expected to span multiple sessions, days
-  of multi-file change, or multi-round requirement review is spec work, not
-  plan work. Say so once (e.g. "this fits a spec workflow like OpenSpec
-  better"), let the user choose, and proceed with a plan only if they insist.