@litfamily/litopencode 1.0.35 → 1.0.36

package/CHANGELOG.md

@@ -5,6 +5,10 @@ are tracked separately from this product history.
 
 ## Unreleased
 
+## 1.0.36 - 2026-10-31
+
+- On OpenCode 2.2 and later, `lit loop`, `litwork` and `/start-work` set OpenCode's native `/goal` for you. The goal carries your task plus what done means here (tests pass, a real-surface check ran, temporary files are cleaned up, the ledger is closed), and each change prints one `LitOpenCode goal:` line. LitOpenCode manages only goals it created: it resumes one that a server restart paused, clears one after OpenCode's verdict and the ledger both say done, and reports a goal you made as left alone without touching it. When OpenCode says the goal is met but the ledger is open, you get a conflict line and no done. Planning, research, review and bare `lit` never set a goal. OpenCode 1 and older OpenCode 2 builds have no `/goal`, so the ledger carries the work and `native-goal-unavailable` is recorded once.
+
 ## 1.0.35 - 2026-10-31
 
 - `lit adhd` counts the other lanes before it offers to resume this session's own work. A session that had started herdr lanes (or sat beside other running sessions) was still told to continue its paused discipline with `go` while they worked; now the box says to wait for them, arms nothing and ends with "Do not type `go` until they finish." A pending approval is still offered, and without lanes the paused discipline is offered as before.

package/README-Ko-KR.md

@@ -1,13 +1,13 @@
-<p align="center"><picture><source media="(prefers-reduced-motion: reduce)" srcset="https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.35/docs/assets/cover-motion-still.webp" /><img src="https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.35/docs/assets/cover-motion.webp" width="100%" alt="LitFamily 모션 커버: 일곱 로봇 패널이 차례로 켜지고, LitOpenCode 로봇의 눈과 테두리가 빛난 뒤 LITFAMILY와 KEEP THE WORK LIT. 문구가 밝아지는 영상" /></picture></p>
+<p align="center"><picture><source media="(prefers-reduced-motion: reduce)" srcset="https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.36/docs/assets/cover-motion-still.webp" /><img src="https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.36/docs/assets/cover-motion.webp" width="100%" alt="LitFamily 모션 커버: 일곱 로봇 패널이 차례로 켜지고, LitOpenCode 로봇의 눈과 테두리가 빛난 뒤 LITFAMILY와 KEEP THE WORK LIT. 문구가 밝아지는 영상" /></picture></p>
 
 # LitOpenCode
 
 **LitOpenCode는 OpenCode용 워크플로 플러그인입니다. 프롬프트에 `lit`만 붙이면 계획하고, 만들고, 확인하고, 기록까지 남겨서 다음 세션이 어디서 멈췄는지 바로 압니다.**
 
 <p align="center">
-<a href="https://www.npmjs.com/package/@litfamily/litopencode"><img src="https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.35/docs/assets/readme/badge-version.svg" alt="1.0.35" /></a>
+<a href="https://www.npmjs.com/package/@litfamily/litopencode"><img src="https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.36/docs/assets/readme/badge-version.svg" alt="1.0.36" /></a>
 <a href="https://www.npmjs.com/package/@litfamily/litopencode"><img src="https://img.shields.io/npm/dm/@litfamily/litopencode?label=downloads&color=D7F75B" alt="월간 npm 다운로드 수" /></a>
-<a href="https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.35/LICENSE"><img src="https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.35/docs/assets/readme/badge-license.svg" alt="MIT 라이선스" /></a>
+<a href="https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.36/LICENSE"><img src="https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.36/docs/assets/readme/badge-license.svg" alt="MIT 라이선스" /></a>
 <a href="https://github.com/wjgoarxiv/litopencode"><img src="https://img.shields.io/github/stars/wjgoarxiv/litopencode?style=social" alt="GitHub 스타" /></a>
 </p>
 
@@ -57,9 +57,9 @@ npm uninstall -g @litfamily/litopencode
 ## 더 보기
 
 - [GitHub의 사용 안내](https://github.com/wjgoarxiv/litopencode/blob/main/docs/guide-Ko-KR.md): 설치 옵션, 자동 인수인계, 문제 해결, 제거
-- [워크플로 상세 안내](https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.35/docs/reference-Ko-KR.md) · [English reference](https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.35/docs/reference.md)
-- [마이그레이션 안내](https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.35/docs/migration.md) · [Changelog](https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.35/CHANGELOG.md) · [개인정보와 네트워크 동작](https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.35/docs/privacy.md)
-- [LitFamily 허브](https://github.com/wjgoarxiv/litfamily) · [MIT 라이선스](https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.35/LICENSE) · [상표 정책](https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.35/TRADEMARK.md) · [ASCII 글꼴 라이선스](https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.35/docs/assets/readme/JetBrainsMono-OFL.txt)
+- [워크플로 상세 안내](https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.36/docs/reference-Ko-KR.md) · [English reference](https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.36/docs/reference.md)
+- [마이그레이션 안내](https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.36/docs/migration.md) · [Changelog](https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.36/CHANGELOG.md) · [개인정보와 네트워크 동작](https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.36/docs/privacy.md)
+- [LitFamily 허브](https://github.com/wjgoarxiv/litfamily) · [MIT 라이선스](https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.36/LICENSE) · [상표 정책](https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.36/TRADEMARK.md) · [ASCII 글꼴 라이선스](https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.36/docs/assets/readme/JetBrainsMono-OFL.txt)
 
 <details>
 <summary>ASCII 로고 복사</summary>

package/README.md

@@ -1,13 +1,13 @@
-<p align="center"><picture><source media="(prefers-reduced-motion: reduce)" srcset="https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.35/docs/assets/cover-motion-still.webp" /><img src="https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.35/docs/assets/cover-motion.webp" width="100%" alt="LitFamily motion cover: seven armored robots power on one by one, the LitOpenCode robot wakes with glowing eyes and a lit frame, then LITFAMILY and KEEP THE WORK LIT. light up." /></picture></p>
+<p align="center"><picture><source media="(prefers-reduced-motion: reduce)" srcset="https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.36/docs/assets/cover-motion-still.webp" /><img src="https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.36/docs/assets/cover-motion.webp" width="100%" alt="LitFamily motion cover: seven armored robots power on one by one, the LitOpenCode robot wakes with glowing eyes and a lit frame, then LITFAMILY and KEEP THE WORK LIT. light up." /></picture></p>
 
 # LitOpenCode
 
 **LitOpenCode is a workflow plugin for OpenCode. Add `lit` to a prompt and the work gets planned, built, checked and written down, so the next session knows where you stopped.**
 
 <p align="center">
-<a href="https://www.npmjs.com/package/@litfamily/litopencode"><img src="https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.35/docs/assets/readme/badge-version.svg" alt="1.0.35" /></a>
+<a href="https://www.npmjs.com/package/@litfamily/litopencode"><img src="https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.36/docs/assets/readme/badge-version.svg" alt="1.0.36" /></a>
 <a href="https://www.npmjs.com/package/@litfamily/litopencode"><img src="https://img.shields.io/npm/dm/@litfamily/litopencode?label=downloads&color=D7F75B" alt="npm downloads per month" /></a>
-<a href="https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.35/LICENSE"><img src="https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.35/docs/assets/readme/badge-license.svg" alt="MIT license" /></a>
+<a href="https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.36/LICENSE"><img src="https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.36/docs/assets/readme/badge-license.svg" alt="MIT license" /></a>
 <a href="https://github.com/wjgoarxiv/litopencode"><img src="https://img.shields.io/github/stars/wjgoarxiv/litopencode?style=social" alt="GitHub stars" /></a>
 </p>
 
@@ -57,9 +57,9 @@ npm uninstall -g @litfamily/litopencode
 ## More
 
 - [Guide on GitHub](https://github.com/wjgoarxiv/litopencode/blob/main/docs/guide.md): install options, automatic handoff, troubleshooting and removal.
-- [Workflow reference](https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.35/docs/reference.md)
-- [Migration notes](https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.35/docs/migration.md) · [Changelog](https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.35/CHANGELOG.md) · [Privacy and network behavior](https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.35/docs/privacy.md)
-- [LitFamily hub](https://github.com/wjgoarxiv/litfamily) · [MIT license](https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.35/LICENSE) · [Trademark policy](https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.35/TRADEMARK.md) · [ASCII font license](https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.35/docs/assets/readme/JetBrainsMono-OFL.txt)
+- [Workflow reference](https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.36/docs/reference.md)
+- [Migration notes](https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.36/docs/migration.md) · [Changelog](https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.36/CHANGELOG.md) · [Privacy and network behavior](https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.36/docs/privacy.md)
+- [LitFamily hub](https://github.com/wjgoarxiv/litfamily) · [MIT license](https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.36/LICENSE) · [Trademark policy](https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.36/TRADEMARK.md) · [ASCII font license](https://cdn.jsdelivr.net/npm/@litfamily/litopencode@1.0.36/docs/assets/readme/JetBrainsMono-OFL.txt)
 
 <details>
 <summary>Copy ASCII logo</summary>

package/dist/activation-primary-prompts.js

@@ -80,9 +80,13 @@ Checkpoint as you go so progress is durable and incremental — never batch it t
 
 # OpenCode goal handoff
 
-OpenCode does not expose a native goal primitive in the verified plugin or CLI surface.
-Use LitOpenCode-owned durable goal state under .litopencode/litgoal/lit-loop instead of
-claiming a host-native /goal integration. If a request refers to a Codex-native goal,
+OpenCode 2.2 and later has a native /goal. On such a host LitOpenCode sets, resumes and clears
+one for lit-loop, start-work and litwork by itself and prints a "LitOpenCode goal:" line for each
+change. Do not type /goal yourself, and never touch a goal the user made. OpenCode 1 and older
+OpenCode 2 hosts have none; the work then runs on the ledger alone (native-goal-unavailable).
+The durable ledger under .litopencode/litgoal/lit-loop is the evidence record on every host:
+a goal counts as done only when OpenCode's verdict and the ledger both say so, so never
+report done while the ledger is open. If a request refers to a Codex-native goal,
 translate it into LitOpenCode's durable ledger semantics and make that adaptation
 explicit before execution.
 

package/dist/activation.js

@@ -12,6 +12,8 @@ import { typedPromptReply } from "./adhd-next.js";
 import { decideReentry, recordActivation } from "./activation-reentry.js";
 import { startTypedWork, typedStartArgument } from "./start-work-typed.js";
 import { micro, supportsMarkGlyphs } from "./lit-mark.js";
+import { recordNativeGoalUnavailable } from "./native-goal-ledger.js";
+import { nativeGoalRoute } from "./v2/native-goal.js";
 // Prompt modules preserve minimum-first, single-task or few-task planning, avoidable custom code review,
 // and external-source safety; this module only coordinates their unchanged activation surfaces.
 export { litHandoffPromptInjection, scientificVisualizationPromptInjection } from "./activation-managed-prompts.js";
@@ -228,6 +230,9 @@ export function createChatMessageActivationHook(projectRoot, options = {}) {
             return;
         }
         await options.onSkillActivation?.(input.sessionID, mode, appendedLit);
+        const goalRoute = nativeGoalRoute(mode, triggerText ?? "");
+        if (goalRoute !== undefined)
+            await recordNativeGoalUnavailable(projectRoot, input.sessionID, goalRoute, "opencode-1");
         if (mode === "lit-scientific-visualization") {
             options.onScientificVisualizationActivation?.(input.sessionID);
         }

package/dist/commands.js

@@ -9,8 +9,18 @@ import { writeNext } from "./adhd-next.js";
 import { autoHandoffSettingText } from "./auto-handoff.js";
 import { formatResolvedPlanNotice, formatSavedPlanNotice, parsePlanSaveArgument, persistApprovedPlan, PlanScopeError, resolveLatestDurablePlan } from "./durable-plan.js";
 import { isWorkflowFamilyMode, workflowFamilyCommandDefinitions } from "./workflow-families.js";
+import { recordNativeGoalUnavailable } from "./native-goal-ledger.js";
+import { nativeGoalRoute } from "./v2/native-goal.js";
 import { captureKnowledgeEvent, inspectKnowledge, queryKnowledge, recoverKnowledge, reviewKnowledgeRecord } from "./knowledge.js";
 export { litActivationBanner, startWorkPromptInjection } from "./activation.js";
+/**
+ * The four loop commands share one prompt, and an installed alias file hands the host exactly that text,
+ * so the prompt alone cannot say which command was typed. A last line names it; the plugin reads it to tell
+ * `/lit-loop` and `/litwork` (which set a native goal) from bare `/lit` (which does not).
+ */
+function loopCommandText(id) {
+    return `${litLoopPromptInjection}\nCommand route: "${id}"`;
+}
 export const litOpenCodeCommands = Object.freeze([
     ...workflowFamilyCommandDefinitions,
     {
@@ -35,7 +45,7 @@ export const litOpenCodeCommands = Object.freeze([
         title: "LitOpenCode",
         description: "Activate the LitOpenCode model probe line and durable goal loop.",
         banner: activationBanner("lit"),
-        activationText: litLoopPromptInjection
+        activationText: loopCommandText("lit")
     },
     {
         id: "lit-loop",
@@ -43,7 +53,7 @@ export const litOpenCodeCommands = Object.freeze([
         title: "LitOpenCode Lit Loop",
         description: "Activate the full LitOpenCode durable lit-loop prompt.",
         banner: activationBanner("lit-loop"),
-        activationText: litLoopPromptInjection
+        activationText: loopCommandText("lit-loop")
     },
     {
         id: "litwork",
@@ -51,7 +61,7 @@ export const litOpenCodeCommands = Object.freeze([
         title: "LitOpenCode Work Loop",
         description: "Resume a LitOpenCode work loop with durable ledger-backed progress.",
         banner: activationBanner("litwork"),
-        activationText: litLoopPromptInjection
+        activationText: loopCommandText("litwork")
     },
     {
         id: "lit-work",
@@ -59,7 +69,7 @@ export const litOpenCodeCommands = Object.freeze([
         title: "LitOpenCode Work Loop",
         description: "Hyphenated alias for /litwork.",
         banner: activationBanner("lit-work"),
-        activationText: litLoopPromptInjection
+        activationText: loopCommandText("lit-work")
     },
     {
         id: "start-work",
@@ -664,6 +674,9 @@ export function createCommandActivationHook(projectRoot, options = {}) {
             }
         });
         await options.onSkillActivation?.(input.sessionID, command.id);
+        const goalRoute = nativeGoalRoute(command.id, "");
+        if (goalRoute !== undefined)
+            await recordNativeGoalUnavailable(projectRoot, input.sessionID, goalRoute, "opencode-1");
         if (command.id === "lit-scientific-visualization") {
             options.onScientificVisualizationActivation?.(input.sessionID);
         }

package/dist/native-goal-ledger.d.ts

@@ -0,0 +1,43 @@
+export type NativeGoalLedgerEvent = {
+    readonly type: "native-goal.created";
+    readonly goalID: string;
+} | {
+    readonly type: "native-goal.resumed";
+    readonly goalID: string;
+} | {
+    readonly type: "native-goal.cleared";
+    readonly goalID: string;
+} | {
+    readonly type: "native-goal.left-alone";
+    readonly goalID: string;
+    readonly status: string;
+} | {
+    readonly type: "native-goal.conflict";
+    readonly goalID: string;
+    readonly reason: string;
+} | {
+    readonly type: "native-goal.failed";
+    readonly step: string;
+    readonly detail: string;
+} | {
+    readonly type: "native-goal.unavailable";
+    readonly host: string;
+};
+export type NativeGoalOwnership = {
+    readonly goalID: string | undefined;
+    readonly resumes: number;
+    readonly createdAt: string | undefined;
+};
+export declare function recordNativeGoal(projectRoot: string, sessionID: string, route: string | undefined, event: NativeGoalLedgerEvent): Promise<boolean>;
+/** The goal id LitOpenCode created for this session and has not cleared, with its resume count. */
+export declare function nativeGoalOwnership(projectRoot: string, sessionID: string): Promise<NativeGoalOwnership>;
+/** OpenCode 1 and older OpenCode 2 hosts have no `/goal`: say so once per session and route. */
+export declare function recordNativeGoalUnavailable(projectRoot: string, sessionID: string, route: string, host: string): Promise<void>;
+/**
+ * True when the evidence ledger holds a goal for this session that is complete and was last written after
+ * the native goal was created. A session's first ledger goal stays complete for good, so an older one must
+ * not close a later native goal.
+ */
+export declare function ledgerGoalDone(projectRoot: string, sessionID: string, since?: string): Promise<boolean>;
+/** Whether the ledger already holds an event of this type for the session (used to say a thing once). */
+export declare function nativeGoalRecorded(projectRoot: string, sessionID: string, type: NativeGoalLedgerEvent["type"], route?: string): Promise<boolean>;

package/dist/native-goal-ledger.js

@@ -0,0 +1,74 @@
+// The native-goal records in LitOpenCode's own ledger (`.litopencode/litgoal`). OpenCode's goal has no
+// owner field, so the ledger is where LitOpenCode remembers which goal id it created, how often it
+// resumed it, and that a host had no `/goal`. Every write is best-effort: a ledger failure never blocks
+// the work, and a read failure reads as "owns nothing", which only makes LitOpenCode do less.
+import { createLitGoalOperations, readEvidenceLedger } from "./ledger.js";
+export async function recordNativeGoal(projectRoot, sessionID, route, event) {
+    try {
+        const operations = createLitGoalOperations(projectRoot);
+        await operations.init();
+        await operations.append({ ...event, sessionID, ...(route === undefined ? {} : { route }), timestamp: new Date().toISOString() });
+        return true;
+    }
+    catch { // no-excuse-ok: catch -- a ledger failure must never block the user's work.
+        return false;
+    }
+}
+/** The goal id LitOpenCode created for this session and has not cleared, with its resume count. */
+export async function nativeGoalOwnership(projectRoot, sessionID) {
+    let goalID;
+    let createdAt;
+    let resumes = 0;
+    try {
+        for (const event of await createLitGoalOperations(projectRoot).read()) {
+            if (event["sessionID"] !== sessionID || typeof event["goalID"] !== "string")
+                continue;
+            if (event.type === "native-goal.created") {
+                goalID = event["goalID"];
+                createdAt = typeof event["timestamp"] === "string" ? event["timestamp"] : undefined;
+                resumes = 0;
+            }
+            else if (event.type === "native-goal.cleared" && event["goalID"] === goalID) {
+                goalID = undefined;
+                createdAt = undefined;
+            }
+            else if (event.type === "native-goal.resumed" && event["goalID"] === goalID) {
+                resumes += 1;
+            }
+        }
+    }
+    catch { // no-excuse-ok: catch -- an unreadable ledger reads as "owns nothing", so LitOpenCode touches nothing.
+        return { goalID: undefined, resumes: 0, createdAt: undefined };
+    }
+    return { goalID, resumes, createdAt };
+}
+/** OpenCode 1 and older OpenCode 2 hosts have no `/goal`: say so once per session and route. */
+export async function recordNativeGoalUnavailable(projectRoot, sessionID, route, host) {
+    if (await nativeGoalRecorded(projectRoot, sessionID, "native-goal.unavailable", route))
+        return;
+    await recordNativeGoal(projectRoot, sessionID, route, { type: "native-goal.unavailable", host });
+}
+/**
+ * True when the evidence ledger holds a goal for this session that is complete and was last written after
+ * the native goal was created. A session's first ledger goal stays complete for good, so an older one must
+ * not close a later native goal.
+ */
+export async function ledgerGoalDone(projectRoot, sessionID, since) {
+    try {
+        const state = await readEvidenceLedger(projectRoot);
+        const floor = since === undefined ? Number.NaN : Date.parse(since);
+        return state.goals.some((goal) => goal.sessionId === sessionID && goal.status === "complete" && (Number.isNaN(floor) || Date.parse(goal.updatedAt) >= floor));
+    }
+    catch { // no-excuse-ok: catch -- an unreadable evidence ledger is not done.
+        return false;
+    }
+}
+/** Whether the ledger already holds an event of this type for the session (used to say a thing once). */
+export async function nativeGoalRecorded(projectRoot, sessionID, type, route) {
+    try {
+        return (await createLitGoalOperations(projectRoot).read()).some((event) => event.type === type && event["sessionID"] === sessionID && (route === undefined || event["route"] === route));
+    }
+    catch { // no-excuse-ok: catch -- an unreadable ledger cannot prove the record exists.
+        return false;
+    }
+}

package/dist/v2/commands.d.ts

@@ -36,6 +36,7 @@ export declare function pluginOwnedCommandIds(roots: readonly string[]): readonl
 export type CommandMark = {
     readonly command: string;
     readonly banner: string;
+    readonly work?: string;
 };
 export declare function createV2Commands(roots: readonly string[], session: CommandSessionLike): {
     definitions: CommandDefinitionLike[];

package/dist/v2/commands.js

@@ -29,8 +29,8 @@ export function createV2Commands(roots, session) {
         async execute(input) {
             const nonce = randomUUID();
             const mark = { command: command.id, banner: command.banner };
-            pending.set(input.sessionID, { nonce, mark });
             const argumentsText = input.prompt.text.trim();
+            pending.set(input.sessionID, { nonce, mark, work: argumentsText });
             if (command.agent !== undefined)
                 await session.switchAgent({ sessionID: input.sessionID, agent: command.agent });
             await session.prompt({
@@ -52,7 +52,7 @@ export function createV2Commands(roots, session) {
         if (expected === undefined || marker.nonce !== expected.nonce)
             return undefined;
         pending.delete(sessionID);
-        return expected.mark;
+        return { ...expected.mark, work: expected.work };
     }
     return {
         definitions,

package/dist/v2/context.d.ts

@@ -3,6 +3,7 @@ import type { AgentEditorLike, ModelEditorLike, PermissionEvaluationLike, Sessio
 import type { CommandEditorLike, CommandSessionLike } from "./commands.ts";
 import type { EventDomainLike, EventModelLike, EventSessionLike } from "./events.ts";
 import type { ToolAfterEvent, ToolBeforeEvent } from "./hooks.ts";
+import type { NativeGoalHostLike } from "./native-goal-runtime.ts";
 import type { ContextEvent, PromptEvent } from "./session-hooks.ts";
 import type { ToolEditorLike } from "./tools.ts";
 export type Registration = {
@@ -28,6 +29,9 @@ type SessionHook = {
     (name: "prompt", callback: Callback<PromptEvent>): Promise<Registration>;
     (name: "context", callback: Callback<ContextEvent>): Promise<Registration>;
     (name: "compaction", callback: Callback<ContextEvent>): Promise<Registration>;
+    (name: "experimental.idle", callback: Callback<{
+        readonly sessionID: string;
+    }>): Promise<Registration>;
 };
 export type SessionDomainLike = {
     readonly get: (input: {
@@ -49,7 +53,8 @@ export type ServerContextLike = {
     readonly command: {
         readonly transform: Transform<CommandEditorLike>;
     };
-    readonly session: SessionDomainLike & SessionModelDomainLike & CommandSessionLike & EventSessionLike & {
+    readonly rpc?: NativeGoalHostLike["rpc"];
+    readonly session: SessionDomainLike & SessionModelDomainLike & CommandSessionLike & EventSessionLike & NativeGoalHostLike["session"] & {
         readonly hook: SessionHook;
     };
     readonly event: EventDomainLike;

package/dist/v2/native-goal-runtime.d.ts

@@ -0,0 +1,74 @@
+import { type NativeGoalRoute } from "./native-goal.ts";
+/** The `opencode.goal` RPC contract as JSON Schema, so the package needs no runtime import of the host's schema library. */
+declare const goalDefinition: Readonly<{
+    id: "opencode.goal";
+    methods: Readonly<{
+        get: Readonly<{
+            input: Readonly<{
+                type: "object";
+                properties: Readonly<{
+                    sessionID: Readonly<{
+                        type: "string";
+                    }>;
+                }>;
+                required: readonly string[];
+            }>;
+            output: Readonly<{}>;
+        }>;
+    }>;
+    events: Readonly<{
+        changed: Readonly<{
+            schema: Readonly<{
+                type: "object";
+                properties: Readonly<{
+                    sessionID: Readonly<{
+                        type: "string";
+                    }>;
+                }>;
+                required: readonly string[];
+            }>;
+        }>;
+    }>;
+}>;
+export type GoalRpcClientLike = {
+    readonly get: (input: {
+        readonly sessionID: string;
+    }) => Promise<unknown>;
+};
+export type NativeGoalHostLike = {
+    /** `context.rpc`; absent on a host that has no RPC domain. */
+    readonly rpc?: (definition: typeof goalDefinition) => GoalRpcClientLike;
+    readonly session: {
+        readonly command: (input: {
+            readonly sessionID: string;
+            readonly name: string;
+            readonly text: string;
+            readonly delivery?: "steer" | "queue";
+        }) => Promise<unknown>;
+        readonly synthetic: (input: {
+            readonly sessionID: string;
+            readonly text: string;
+            readonly description?: string;
+            readonly metadata?: Readonly<Record<string, string>>;
+            readonly resume?: boolean;
+        }) => Promise<unknown>;
+    };
+};
+/** A prompt the host expanded from an installed command alias file arrives as the command body, unmarked. */
+export declare function aliasGoalRoute(input: string): {
+    readonly route: NativeGoalRoute;
+    readonly work: string;
+} | undefined;
+export declare function createNativeGoal(options: {
+    readonly projectRoot: string;
+    readonly host: NativeGoalHostLike;
+}): {
+    /** Starts the goal step for a qualifying activation without holding up the user's prompt. */
+    activate(sessionID: string, route: NativeGoalRoute, work: string): Promise<void>;
+    /** The session finished its model work: clear a finished owned goal or report a conflict. */
+    idle(sessionID: string): Promise<void>;
+    /** Resolves when every started goal step has finished. */
+    settled(): Promise<void>;
+};
+export type NativeGoal = ReturnType<typeof createNativeGoal>;
+export {};

package/dist/v2/native-goal-runtime.js

@@ -0,0 +1,193 @@
+// Drives OpenCode 2's native `/goal` for lit-loop, start-work and litwork. The host has no goal setter:
+// the goal is read through the `opencode.goal` RPC and changed by sending the `/goal` command to the
+// session (`session.command`). Policy lives in native-goal.ts; this file reads the state, performs the one
+// action it returns, prints one line per change as a notice row, and records it in the ledger. Nothing here
+// throws: a failed step is recorded and the work carries on with the ledger alone.
+import { ledgerGoalDone, nativeGoalOwnership, recordNativeGoal, recordNativeGoalUnavailable } from "../native-goal-ledger.js";
+import { litOpenCodeCommands } from "../commands.js";
+import { decideNativeGoal, nativeGoalLine, nativeGoalObjective, nativeGoalRoute } from "./native-goal.js";
+/** The `opencode.goal` RPC contract as JSON Schema, so the package needs no runtime import of the host's schema library. */
+const goalDefinition = Object.freeze({
+    id: "opencode.goal",
+    methods: Object.freeze({
+        get: Object.freeze({
+            input: Object.freeze({ type: "object", properties: Object.freeze({ sessionID: Object.freeze({ type: "string" }) }), required: Object.freeze(["sessionID"]) }),
+            output: Object.freeze({})
+        })
+    }),
+    events: Object.freeze({
+        changed: Object.freeze({ schema: Object.freeze({ type: "object", properties: Object.freeze({ sessionID: Object.freeze({ type: "string" }) }), required: Object.freeze(["sessionID"]) }) })
+    })
+});
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseGoal(value) {
+    if (value === null || value === undefined)
+        return null;
+    if (!isRecord(value) || typeof value.id !== "string" || typeof value.objective !== "string")
+        return "unreadable";
+    if (value.status !== "active" && value.status !== "paused" && value.status !== "complete")
+        return "unreadable";
+    return { id: value.id, objective: value.objective, status: value.status, ...(typeof value.reason === "string" ? { reason: value.reason } : {}) };
+}
+/** OpenCode 2.2.5 answers an RPC it does not register with type `rpc.unavailable`; any other failure is a failed read. */
+function hostLacksGoalRpc(error) {
+    return isRecord(error) && error.type === "rpc.unavailable";
+}
+function failureDetail(error) {
+    const text = error instanceof Error ? error.message : isRecord(error) ? String(error.message ?? error.type ?? "failed") : String(error);
+    return text.replace(/\s+/gu, " ").slice(0, 160);
+}
+/** A prompt the host expanded from an installed command alias file arrives as the command body, unmarked. */
+export function aliasGoalRoute(input) {
+    const text = input.trimStart();
+    for (const command of litOpenCodeCommands) {
+        const head = command.activationText.trim();
+        if (head === "" || !text.startsWith(head))
+            continue;
+        const route = nativeGoalRoute(command.id, "");
+        return route === undefined ? undefined : { route, work: text.slice(head.length) };
+    }
+    return undefined;
+}
+export function createNativeGoal(options) {
+    const { projectRoot, host } = options;
+    const client = host.rpc === undefined ? undefined : host.rpc(goalDefinition);
+    const said = new Set();
+    const running = new Set();
+    async function read(sessionID) {
+        if (client === undefined)
+            return { supported: false };
+        try {
+            return { supported: true, goal: parseGoal(await client.get({ sessionID })) };
+        }
+        catch (error) {
+            return hostLacksGoalRpc(error) ? { supported: false } : { supported: true, goal: "unreadable" };
+        }
+    }
+    async function notice(sessionID, line, key) {
+        if (line === "" || said.has(key))
+            return;
+        said.add(key);
+        try {
+            await host.session.synthetic({ sessionID, text: line, description: line, metadata: { source: "litopencode-goal" }, resume: false });
+        }
+        catch { // no-excuse-ok: catch -- a missing notice row must not stop the work; the ledger holds the record.
+            return;
+        }
+    }
+    async function fail(sessionID, route, step, error) {
+        await recordNativeGoal(projectRoot, sessionID, route, { type: "native-goal.failed", step, detail: failureDetail(error) });
+    }
+    async function perform(sessionID, route, action, goal, work) {
+        const record = goal === null || goal === "unreadable" ? undefined : goal;
+        const key = (name) => `${sessionID}:${name}:${record?.id ?? ""}:${action.kind === "report-conflict" ? action.reason : ""}`;
+        switch (action.kind) {
+            case "none":
+            case "keep":
+                return;
+            case "unavailable": {
+                if (route !== undefined)
+                    await recordNativeGoalUnavailable(projectRoot, sessionID, route, "opencode-2-without-goal-rpc");
+                await notice(sessionID, nativeGoalLine(action, { route }), key("unavailable"));
+                return;
+            }
+            case "report-user-goal": {
+                if (!said.has(key("user-goal")) && record !== undefined) {
+                    await recordNativeGoal(projectRoot, sessionID, route, { type: "native-goal.left-alone", goalID: record.id, status: record.status });
+                }
+                await notice(sessionID, nativeGoalLine(action, { route, ...(record === undefined ? {} : { goal: record }) }), key("user-goal"));
+                return;
+            }
+            case "report-conflict": {
+                if (!said.has(key("conflict"))) {
+                    await recordNativeGoal(projectRoot, sessionID, route, { type: "native-goal.conflict", goalID: record?.id ?? "", reason: action.reason });
+                }
+                await notice(sessionID, nativeGoalLine(action, { route, ...(record === undefined ? {} : { goal: record }) }), key("conflict"));
+                return;
+            }
+            case "create": {
+                const objective = nativeGoalObjective(work, sessionID);
+                try {
+                    await host.session.command({ sessionID, name: "goal", text: objective, delivery: "queue" });
+                }
+                catch (error) {
+                    await fail(sessionID, route, "create", error);
+                    return;
+                }
+                const after = await read(sessionID);
+                const created = after.supported && after.goal !== null && after.goal !== "unreadable" && after.goal.objective === objective ? after.goal : undefined;
+                if (created === undefined) {
+                    await fail(sessionID, route, "create", "the goal was not readable after /goal; ownership not claimed");
+                    return;
+                }
+                await recordNativeGoal(projectRoot, sessionID, route, { type: "native-goal.created", goalID: created.id });
+                await notice(sessionID, nativeGoalLine(action, { route, goal: created }), key("created"));
+                return;
+            }
+            case "resume":
+            case "clear": {
+                if (record === undefined)
+                    return;
+                const control = action.kind;
+                try {
+                    await host.session.command({ sessionID, name: "goal", text: control, delivery: "queue" });
+                }
+                catch (error) {
+                    await fail(sessionID, route, control, error);
+                    return;
+                }
+                const event = control === "resume" ? { type: "native-goal.resumed", goalID: record.id } : { type: "native-goal.cleared", goalID: record.id };
+                await recordNativeGoal(projectRoot, sessionID, route, event);
+                await notice(sessionID, nativeGoalLine(action, { route, goal: record }), key(control));
+                return;
+            }
+        }
+    }
+    /** One decision for one session: `route` set on an activation, absent on an idle check. */
+    async function step(sessionID, route, work) {
+        const owned = await nativeGoalOwnership(projectRoot, sessionID);
+        if (route === undefined && owned.goalID === undefined)
+            return;
+        const state = await read(sessionID);
+        const goal = state.supported ? state.goal : null;
+        const action = decideNativeGoal({
+            route,
+            supported: state.supported,
+            goal,
+            ownedGoalID: owned.goalID,
+            ledgerDone: owned.goalID === undefined ? false : await ledgerGoalDone(projectRoot, sessionID, owned.createdAt),
+            resumes: owned.resumes
+        });
+        await perform(sessionID, route, action, goal, work);
+    }
+    /** One step at a time per session, so a repeated activation sees the goal the first one made. */
+    const chains = new Map();
+    function track(sessionID, run) {
+        const previous = chains.get(sessionID) ?? Promise.resolve();
+        const safe = previous.then(run).catch(() => undefined).finally(() => {
+            running.delete(safe);
+            if (chains.get(sessionID) === safe)
+                chains.delete(sessionID);
+        });
+        chains.set(sessionID, safe);
+        running.add(safe);
+        return safe;
+    }
+    return {
+        /** Starts the goal step for a qualifying activation without holding up the user's prompt. */
+        activate(sessionID, route, work) {
+            return track(sessionID, () => step(sessionID, route, work));
+        },
+        /** The session finished its model work: clear a finished owned goal or report a conflict. */
+        idle(sessionID) {
+            return track(sessionID, () => step(sessionID, undefined, ""));
+        },
+        /** Resolves when every started goal step has finished. */
+        async settled() {
+            while (running.size > 0)
+                await Promise.all([...running]);
+        }
+    };
+}

package/dist/v2/native-goal.d.ts

@@ -0,0 +1,49 @@
+export type NativeGoalRoute = "lit-loop" | "start-work" | "litwork";
+export type NativeGoalRecord = {
+    readonly id: string;
+    readonly objective: string;
+    readonly status: "active" | "paused" | "complete";
+    readonly reason?: string;
+};
+export type NativeGoalInput = {
+    /** The route that is activating now; absent on an idle check. */
+    readonly route: string | undefined;
+    /** Whether this host answers the `opencode.goal` RPC. */
+    readonly supported: boolean;
+    /** The host's goal for the session: null when none, "unreadable" when the read failed. */
+    readonly goal: NativeGoalRecord | null | "unreadable";
+    /** The goal id LitOpenCode created for this session, from its ledger. */
+    readonly ownedGoalID: string | undefined;
+    /** Whether LitOpenCode's evidence ledger marks the session's goal complete. */
+    readonly ledgerDone: boolean;
+    /** How many times LitOpenCode already resumed the owned goal. */
+    readonly resumes: number;
+};
+export type NativeGoalAction = {
+    readonly kind: "none";
+} | {
+    readonly kind: "create";
+} | {
+    readonly kind: "keep";
+} | {
+    readonly kind: "resume";
+} | {
+    readonly kind: "clear";
+} | {
+    readonly kind: "report-user-goal";
+} | {
+    readonly kind: "report-conflict";
+    readonly reason: string;
+} | {
+    readonly kind: "unavailable";
+};
+/** The qualifying route for a chat mode or command id, or undefined for every other route. */
+export declare function nativeGoalRoute(mode: string, text: string): NativeGoalRoute | undefined;
+export declare function decideNativeGoal(input: NativeGoalInput): NativeGoalAction;
+/** The text sent to `/goal`: the work, then the conditions OpenCode's reviewer judges it against. */
+export declare function nativeGoalObjective(work: string, sessionID?: string): string;
+/** The single line announced for an action; an empty string when nothing changed. */
+export declare function nativeGoalLine(action: NativeGoalAction, detail: {
+    readonly route?: string;
+    readonly goal?: Pick<NativeGoalRecord, "id" | "status" | "objective">;
+}): string;

package/dist/v2/native-goal.js

@@ -0,0 +1,71 @@
+// Policy for OpenCode 2's native `/goal`. It is pure: the route, the goal record the host reports and the
+// state of LitOpenCode's own ledger go in; one action comes out. The host has no setter for a goal, only
+// the `/goal` command, and that command replaces any goal that exists, so every create is decided here
+// first. LitOpenCode manages only a goal it created (the ledger remembers the id); a goal the user made
+// is reported and never touched. Done needs two things: OpenCode's verdict and the ledger.
+import { containsSecret } from "../secret-shapes.js";
+const goalRoutes = new Set(["lit-loop", "start-work", "litwork"]);
+/** The host pauses a goal on a restart; it is the only pause that is safe to resume without asking. */
+const restartPause = "The server restarted while the goal was active";
+const maxResumes = 2;
+const maxObjective = 4000;
+const completionConditions = "Done only when all of these hold: the change works and the project's tests pass; a real-surface check of the path a user touches has run; temporary files are cleaned up with a cleanup receipt; and LitOpenCode's evidence ledger (.litopencode/litgoal) marks the goal complete.";
+/** The qualifying route for a chat mode or command id, or undefined for every other route. */
+export function nativeGoalRoute(mode, text) {
+    if (mode === "lit-loop" || mode === "start-work")
+        return mode;
+    if (mode === "litwork" || mode === "lit-work")
+        return "litwork";
+    if (mode !== "lit-task")
+        return undefined;
+    const first = text.trim().replace(/^\//u, "").split(/\s+/u)[0]?.toLowerCase();
+    return first === "litwork" || first === "lit-work" ? "litwork" : undefined;
+}
+export function decideNativeGoal(input) {
+    const routed = input.route !== undefined;
+    if (routed && !goalRoutes.has(input.route))
+        return { kind: "none" };
+    if (!input.supported)
+        return routed ? { kind: "unavailable" } : { kind: "none" };
+    const goal = input.goal;
+    if (goal === "unreadable")
+        return routed ? { kind: "report-conflict", reason: "the goal state could not be read, so none was set" } : { kind: "none" };
+    if (goal === null)
+        return routed ? { kind: "create" } : { kind: "none" };
+    if (input.ownedGoalID === undefined || goal.id !== input.ownedGoalID)
+        return routed ? { kind: "report-user-goal" } : { kind: "none" };
+    if (goal.status === "complete") {
+        return input.ledgerDone ? { kind: "clear" } : { kind: "report-conflict", reason: "OpenCode says the goal is met but the ledger is still open" };
+    }
+    if (goal.status === "paused") {
+        if (goal.reason === restartPause && input.resumes < maxResumes)
+            return routed ? { kind: "resume" } : { kind: "none" };
+        return routed ? { kind: "report-conflict", reason: `the goal is paused${goal.reason === undefined ? "" : ` (${oneLine(goal.reason, 60)})`} and needs a person to resume it` } : { kind: "none" };
+    }
+    return { kind: "keep" };
+}
+function oneLine(value, limit) {
+    const flat = value.replace(/\s+/gu, " ").trim();
+    return flat.length <= limit ? flat : `${flat.slice(0, limit - 1)}…`;
+}
+/** The text sent to `/goal`: the work, then the conditions OpenCode's reviewer judges it against. */
+export function nativeGoalObjective(work, sessionID) {
+    const flat = work.replace(/\s+/gu, " ").trim();
+    const subject = flat === "" || containsSecret(flat) ? "the work requested in this session" : flat;
+    const conditions = sessionID === undefined || !/^[A-Za-z0-9_-]{1,80}$/u.test(sessionID) ? completionConditions : `${completionConditions} Open that ledger goal with --session-id ${sessionID}.`;
+    const room = maxObjective - conditions.length - 2;
+    return `${oneLine(subject, room)}\n\n${conditions}`;
+}
+/** The single line announced for an action; an empty string when nothing changed. */
+export function nativeGoalLine(action, detail) {
+    const id = detail.goal === undefined ? "" : ` ${detail.goal.id.slice(0, 8)}`;
+    switch (action.kind) {
+        case "create": return `LitOpenCode goal: created for ${detail.route ?? "this work"}; OpenCode judges it, the ledger must agree`;
+        case "resume": return `LitOpenCode goal: resumed${id} after a server restart`;
+        case "clear": return `LitOpenCode goal: cleared${id}; OpenCode's verdict and the ledger both say done`;
+        case "report-user-goal": return `LitOpenCode goal: left yours alone${detail.goal === undefined ? "" : ` (${detail.goal.status}: ${oneLine(detail.goal.objective, 60)})`}`;
+        case "report-conflict": return `LitOpenCode goal: conflict, ${oneLine(action.reason, 120)}; not reporting done`;
+        case "unavailable": return "LitOpenCode goal: native-goal-unavailable (this OpenCode has no /goal); the ledger carries the work";
+        default: return "";
+    }
+}

package/dist/v2/server.js

@@ -11,6 +11,7 @@ import { applyLitAgents, createSessionModelRoute, enforcePlanningOnly, planLitAg
 import { createSessionLookupV2, projectRootFromLocation } from "./context.js";
 import { createV2Commands } from "./commands.js";
 import { createV2Events } from "./events.js";
+import { createNativeGoal } from "./native-goal-runtime.js";
 import { createV2ToolHooks } from "./hooks.js";
 import { createV2SessionHooks } from "./session-hooks.js";
 import { addLitTools, litToolsForProject } from "./tools.js";
@@ -46,6 +47,7 @@ export async function setupLitOpenCodeServer(context) {
         model: context.model,
         onSessionDeleted: (sessionID) => sessionHooks.clear(sessionID)
     });
+    const nativeGoal = createNativeGoal({ projectRoot: root, host: { ...(context.rpc === undefined ? {} : { rpc: context.rpc }), session: context.session } });
     const sessionHooks = createV2SessionHooks({
         projectRoot: root,
         config: loaded.config,
@@ -54,14 +56,22 @@ export async function setupLitOpenCodeServer(context) {
         requestOptions: agentPlan.requestOptions,
         autoHandoffRoute: events.route,
         extraSystem: events.systemText,
-        acceptCommandMark: commands.acceptMark
+        acceptCommandMark: commands.acceptMark,
+        nativeGoal
     });
     await context.session.hook("prompt", sessionHooks.prompt);
     await context.session.hook("context", sessionHooks.context);
     await context.session.hook("compaction", sessionHooks.compaction);
+    try {
+        await context.session.hook("experimental.idle", ({ sessionID }) => nativeGoal.idle(sessionID));
+    }
+    catch { // no-excuse-ok: catch -- an OpenCode 2 build without the idle hook has no native /goal either; the plugin still starts.
+        // Activation-time goal handling still runs; only the finished-goal check is missing.
+    }
     const stopEvents = events.start(context.event);
     return async () => {
         await stopEvents();
+        await nativeGoal.settled();
         deliverableHedgeGuard.dispose();
         await logger.dispose();
     };

package/dist/v2/session-hooks.d.ts

@@ -2,6 +2,7 @@ import { type ChatActivationMode } from "../activation-routing.ts";
 import { type AutoHandoffRouteMode } from "../auto-handoff.ts";
 import type { LitOpenCodeConfig } from "../config.ts";
 import type { AgentRequestOptions } from "./agents.ts";
+import { type NativeGoal } from "./native-goal-runtime.ts";
 export type SystemPartLike = {
     readonly type: "text";
     readonly text: string;
@@ -45,7 +46,10 @@ export type V2SessionHookOptions = {
     readonly acceptCommandMark?: (sessionID: string, marker: unknown) => {
         readonly command: string;
         readonly banner: string;
+        readonly work?: string;
     } | undefined;
+    /** Sets and manages OpenCode 2's native goal for lit-loop, start-work and litwork. */
+    readonly nativeGoal?: NativeGoal;
 };
 /**
  * `opencode2 run "lit fix it"` sends the message wrapped in double quotes (each multi-word argument is

package/dist/v2/session-hooks.js

@@ -17,6 +17,8 @@ import { startTypedWork, typedStartArgument } from "../start-work-typed.js";
 import { createLitGoalOperations } from "../ledger.js";
 import { applyCompactionRuleReset, applyStaticRuleInjection } from "../rules/hooks.js";
 import { isReadOnlyWorkflowFamilyPlan } from "../workflow-families.js";
+import { aliasGoalRoute } from "./native-goal-runtime.js";
+import { nativeGoalRoute } from "./native-goal.js";
 const bundledRulesDir = fileURLToPath(new URL("../../rules/bundled-rules", import.meta.url));
 /**
  * `opencode2 run "lit fix it"` sends the message wrapped in double quotes (each multi-word argument is
@@ -63,6 +65,12 @@ export function createV2SessionHooks(options) {
         }
         return state;
     }
+    /** Starts the native-goal step for a qualifying route; it never holds up or fails the prompt. */
+    function startNativeGoal(sessionID, route, work) {
+        if (route === undefined || options.nativeGoal === undefined)
+            return;
+        void options.nativeGoal.activate(sessionID, route, work);
+    }
     async function lookup(sessionID) {
         try {
             const session = await options.getSession(sessionID);
@@ -88,6 +96,7 @@ export function createV2SessionHooks(options) {
         }
         event.metadata = { ...rest, litopencode: { command: accepted.command, banner: accepted.banner, source: "command" } };
         options.onActivation?.(event.sessionID, accepted.command);
+        startNativeGoal(event.sessionID, nativeGoalRoute(accepted.command, ""), accepted.work ?? "");
         return true;
     }
     async function prompt(event) {
@@ -143,9 +152,13 @@ export function createV2SessionHooks(options) {
             options.onActivation?.(event.sessionID, "lit-adhd");
             return;
         }
+        const alias = aliasGoalRoute(input);
+        if (alias !== undefined)
+            startNativeGoal(event.sessionID, alias.route, alias.work);
         const mode = detectChatActivationMode(input, session.agent);
         if (mode === undefined)
             return;
+        startNativeGoal(event.sessionID, nativeGoalRoute(mode, input), input);
         const trigger = mode === "lit-handoff" ? "handoff" : mode === "lit-scientific-visualization" ? mode : "lit";
         let activation = promptForChatActivationMode(mode, input);
         if (mode === "lit-adhd")

package/docs/assets/readme/badge-version.svg

@@ -1 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="146" height="20" role="img" aria-label="release: 1.0.35"><title>release: 1.0.35</title><g shape-rendering="crispEdges"><rect width="49" height="20" fill="#080d14"/><rect x="49" width="97" height="20" fill="#ff6337"/></g><g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110"><text x="255" y="140" textLength="390" transform="scale(.1)">release</text><text x="965" y="140" textLength="870" transform="scale(.1)" fill="#080D14">1.0.35</text></g></svg>
+<svg xmlns="http://www.w3.org/2000/svg" width="146" height="20" role="img" aria-label="release: 1.0.36"><title>release: 1.0.36</title><g shape-rendering="crispEdges"><rect width="49" height="20" fill="#080d14"/><rect x="49" width="97" height="20" fill="#ff6337"/></g><g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110"><text x="255" y="140" textLength="390" transform="scale(.1)">release</text><text x="965" y="140" textLength="870" transform="scale(.1)" fill="#080D14">1.0.36</text></g></svg>

package/docs/migration.md

@@ -29,7 +29,7 @@ This guide describes the supported migration shape for moving an OpenCode workfl
 - Planning routes now produce proportionate objective-achievable checklists rather than relying on a later review pass to discover missing execution detail. Each retained item carries action/output/verification, while risky or multi-stage work receives SDD-like gates only when justified. `/review-work` accepts both draft plans (read-only `PASS`/`ITERATE`/`NEEDS-CONTEXT`) and completed work (the existing five-lane review); it never implements a draft plan.
 - Keep `/start-work` as the native executable handoff to `lit-implement`. Chat-only start-work activation must begin with `start-work` or `lit start work`; diagnostic, copied, quoted, and blockquote mentions must not select start-work or append a false start-work event. An independent final `lit` remains an ordinary `lit-loop` activation.
 - Schema-3 bounded-authority state is package-owned under `.litopencode/litgoal/lit-loop`. Existing activity ledgers remain readable; strict `/start-work init|resume|cancel|complete|status` directives create and advance the separate work snapshot and bounded journal. Resume is trusted-user-only and the generic `start-work` tool does not gain a resume action.
-- Do not claim native goal binding unless the current OpenCode CLI or plugin API exposes a goal primitive; use LitOpenCode-owned `.litopencode/litgoal` state for durable goal behavior.
+- Native goal binding exists only on OpenCode 2.2 and later (the `opencode.goal` RPC and the `/goal` command) and only for lit-loop, start-work and litwork; on OpenCode 1 and older OpenCode 2 hosts do not claim it, and keep LitOpenCode-owned `.litopencode/litgoal` state as the evidence record everywhere.
 
 ## Durable State
 

package/docs/reference.md

@@ -255,8 +255,11 @@ folder would cover it. Paths in code fences and commands quoted in an inline cod
 When typed start-work begins, each valid `Scope roots:` line becomes a grant of the run, so it does
 not pause for a folder the approved plan named; the folder must exist then.
 
-Native goal verdict: the OpenCode host surface does not currently expose a native goal primitive;
-LitOpenCode uses `.litopencode/litgoal` instead. Static skills are installed under
+Native goal verdict: OpenCode 2.2 and later has a native `/goal`, and LitOpenCode sets, resumes and
+clears one only for lit-loop, start-work and litwork, only for goals it created; a goal you made is
+reported and left alone. OpenCode 1 and older OpenCode 2 hosts record `native-goal-unavailable`.
+The ledger under `.litopencode/litgoal` is the evidence record on every host, and done needs both
+OpenCode's verdict and the ledger. Static skills are installed under
 `skills/*/SKILL.md` and remain documentation unless a documented OpenCode route selects them.
 
 ## Skill learning state

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@litfamily/litopencode",
-  "version": "1.0.35",
+  "version": "1.0.36",
   "description": "Workflow plugin for OpenCode: add lit to a prompt and the work is planned, built, checked and written down so the next session can pick it up.",
   "keywords": [
     "opencode",
@@ -74,7 +74,7 @@
   },
   "devDependencies": {
     "@opencode-ai/plugin": "^1.17.6",
-    "@opencode/plugin": "2.0.32",
+    "@opencode/plugin": "2.2.5",
     "@types/node": "^24.12.2",
     "picomatch": "^4.0.5",
     "typescript": "^5.9.3"

package/skills/litgoal/SKILL.md

@@ -128,7 +128,7 @@ litgoal sets and keeps the finish line; lit-loop and start-work run toward it.
 - **Keeps.** The goal survives context loss, compaction, and a new session. Status reads the ledger, not chat memory; an entry is a lead until the evidence is replayed.
 - **Does not run.** litgoal never edits product files and never executes the work. `lit-loop` pursues the criteria turn by turn, and `start-work` executes an approved plan against them under the schema-3 bounded-authority record. Both keep their progress and verification receipts in the same `.litopencode/litgoal` state.
 - **Does not decide completion.** A criterion is met when its evidence is replayed on the real surface, not when a turn says so. `review-work` challenges the claim before it stands.
-- **Is not the host's goal feature.** The verified OpenCode host exposes no native goal primitive, so litgoal is package-owned durable state. See `native-goal-verdict` before promising a host-side objective.
+- **Is not the host's goal feature.** litgoal is package-owned durable state on every host. OpenCode 2.2 and later also has a native `/goal`, which LitOpenCode sets for lit-loop, start-work and litwork and mirrors from this ledger; done needs both. See `native-goal-verdict` before promising a host-side objective.
 
 The route name, the command, and the skill are one word: `litgoal`. `/lit-goal` is the hyphenated alias.
 
@@ -188,7 +188,7 @@ remains denied.
 
 ## Ledger Operating Model
 
-The litgoal skill explains the package-owned state model that LitOpenCode uses when the verified OpenCode host does not expose a native goal primitive. The state root is `.litopencode/litgoal`, and the primary loop ledger is `.litopencode/litgoal/lit-loop/ledger.jsonl`. This path is local workflow state, not package source. It should never be treated as a release payload, a benchmark fixture, or a substitute for current tests. It exists so the loop can survive context loss, command interruption, and cross-session continuation without storing raw secrets or pretending that chat memory is durable.
+The litgoal skill explains the package-owned state model that LitOpenCode uses on every host, including OpenCode 2.2 and later where a native `/goal` also exists and the ledger stays the second half of done. The state root is `.litopencode/litgoal`, and the primary loop ledger is `.litopencode/litgoal/lit-loop/ledger.jsonl`. This path is local workflow state, not package source. It should never be treated as a release payload, a benchmark fixture, or a substitute for current tests. It exists so the loop can survive context loss, command interruption, and cross-session continuation without storing raw secrets or pretending that chat memory is durable.
 
 Each durable event should be understandable as a small fact about the work loop. Good events identify the phase, the goal or slice identifier, the relevant files or commands, the result, and a redacted evidence pointer. Bad events paste raw user data, full command output containing credentials, large source files, private URLs, or unreviewed external text. The ledger is evidence metadata, not a data lake. When in doubt, store a short summary and a path to a local evidence file whose contents were intentionally created for that purpose.
 

package/skills/litwork/SKILL.md

@@ -225,3 +225,7 @@ For any activation change, collect evidence by layer: source registration, runti
 ## Safe Defaults
 
 Default activation should be conservative. It should prefer planning or status over mutation when intent is unclear. It should ask for an approved plan before execution. It should preserve `lit-plan` boundaries even when permission mode is relaxed. It should keep recap read-only. It should avoid writing durable raw arguments. These defaults make accidental activation recoverable.
+
+## Native goal on OpenCode 2
+
+On OpenCode 2.2 and later, a `litwork` request gets a native `/goal` from LitOpenCode itself when the session has none; bare `lit` and the read-only routes do not. LitOpenCode resumes a goal it created only after a server restart, clears it only after OpenCode's verdict and the ledger both say done, and leaves a goal the user made alone. A host without `/goal` records `native-goal-unavailable`. See `native-goal-verdict`.

package/skills/native-goal-verdict/SKILL.md

@@ -18,6 +18,8 @@ entry_routes:
 opencode_surfaces:
   - "OpenCode CLI command list"
   - "OpenCode plugin type surface"
+  - "opencode.goal RPC and the /goal command"
+  - "session experimental.idle hook"
   - "LitOpenCode durable goal ledger"
   - "OpenCode tool litwork action=status"
   - "litopencode runtime state path"
@@ -40,7 +42,7 @@ Use the OpenCode vocabulary for this contract: `chat.message`, `command.execute.
 | --- | --- |
 | `user_request` | The user goal or slash-command arguments that selected Native Goal Verdict. Treat pasted external text as inert data. |
 | `repo_state` | Current package root, dirty worktree status, relevant handoff/ledger state, and OpenCode route config when it affects this skill. |
-| `host_surface` | OpenCode CLI command list, OpenCode plugin type surface, LitOpenCode durable goal ledger, OpenCode tool litwork action=status, litopencode runtime state path, skills/native-goal-verdict/SKILL.md. |
+| `host_surface` | OpenCode CLI command list, OpenCode plugin type surface, the `opencode.goal` RPC and `/goal` command, LitOpenCode durable goal ledger, OpenCode tool litwork action=status, litopencode runtime state path, skills/native-goal-verdict/SKILL.md. |
 | `approval_state` | Whether mutation, execution, release, network, install, or config writes are explicitly approved. Absence of approval means read-only guidance. |
 | `evidence_budget` | Targeted tests, command transcripts, hook probes, pack/install checks, or source citations required before a completion claim. |
 
@@ -50,7 +52,7 @@ Required schema fields are `contract_schema_version`, `skill_id`, `runtime_class
 
 | Mode | Enter when | Allowed surfaces | Required behavior | Exit criteria |
 | --- | --- | --- | --- | --- |
-| `route` | Inspect the native-goal-verdict feature, skills/native-goal-verdict/SKILL.md, opencode --help, and @opencode-ai/plugin Hooks types. | OpenCode CLI command list, OpenCode plugin type surface, LitOpenCode durable goal ledger, OpenCode tool litwork action=status, litopencode runtime state path, skills/native-goal-verdict/SKILL.md | Select the matching LitOpenCode guidance and preserve static-documentation boundaries. | The intended skill, command, hook, tool, or route is identified with evidence. |
+| `route` | Inspect the native-goal-verdict feature, skills/native-goal-verdict/SKILL.md, the host's `/goal` command, and the `@opencode/plugin` goal and idle types. | OpenCode CLI command list, OpenCode plugin type surface, LitOpenCode durable goal ledger, OpenCode tool litwork action=status, litopencode runtime state path, skills/native-goal-verdict/SKILL.md | Select the matching LitOpenCode guidance and preserve static-documentation boundaries. | The intended skill, command, hook, tool, or route is identified with evidence. |
 | `execute` | The user explicitly approved implementation or the surface is already an execution surface. | Approved OpenCode agents, tools, and repository commands. | Apply minimum-first changes, protect unrelated files, and keep evidence checkpoints. | Tests and real-surface probes pass or a precise blocker is reported. |
 | `review` | A DoneClaim, release claim, or completion claim is about to be made. | Review-work, targeted tests, scanners, CLI probes, package checks. | Challenge scope, outputs, evidence, safety, and cleanup. | Findings are resolved or listed as risks/limitations. |
 | `blocked` | Required approval, credentials, host capability, or evidence is missing. | Read-only reporting only. | Stop without inventing success and state the smallest unblocker. | User supplies the missing decision/evidence or scope changes. |
@@ -121,96 +123,68 @@ This is static documentation for LitOpenCode runtime discovery. Do not execute c
 
 ## Verdict
 
-The verified OpenCode host surface does not currently expose a native goal primitive through the local CLI command list or the `@opencode-ai/plugin` Hooks type surface. LitOpenCode must not promise direct native goal binding unless a future OpenCode release exposes that primitive.
+OpenCode 2.2 and later has a native `/goal`; OpenCode 1 and OpenCode 2 builds before 2.2 do not. The goal belongs to a session: a built-in plugin keeps `{ id, objective, status, reason, rounds }` for it, a reviewer decides after each idle turn whether the objective is met, and the user steers it with `/goal <objective> | pause | resume | clear`. A plugin reads the goal through the `opencode.goal` RPC (`get({ sessionID })`) and changes it only by sending the `/goal` command to the session. The record has no owner field.
 
-LitOpenCode therefore treats durable goal state as a package-owned capability under `.litopencode/litgoal`, with activation through `lit`, `litwork`, `start-work`, `review-work`, tools, commands, and plugin hooks.
+LitOpenCode uses that surface in a narrow way. On `lit-loop`, `start-work` and `litwork` it checks the session's goal first and sets one only when none exists. The objective is the work plus the completion conditions: tests pass, a real-surface check ran, temporary files are cleaned up with a receipt, and the ledger marks the goal complete. Read-only routes (`lit-plan`, `lit-research`, `review-work`, `lit-recap`, `lit-adhd`, `lit-brainstorm` and the rest) never set a goal.
 
-## Verification Route
+The ledger under `.litopencode/litgoal` stays the evidence record on every host. A goal counts as done only when OpenCode's verdict and the ledger both say so. When OpenCode says the goal is met while the ledger is still open, LitOpenCode prints a conflict line and does not report done.
 
-- Check `opencode --help` for the current CLI command list.
-- Check the installed `@opencode-ai/plugin` Hooks type for plugin extension points.
-- Run `node --test test/runtime-skills.test.mjs`.
-- Run `node --test test/docs.test.mjs`.
+## What LitOpenCode may and may not touch
 
-## Safety Notes
+- It remembers the goal id it created (ledger event `native-goal.created`) and treats that goal as its own. Any other goal is the user's.
+- Its own goal: it resumes one that the server paused on a restart (at most twice), and clears one after both verdicts agree. A goal paused for any other reason (the user, the round limit, no progress, a blocked reviewer) is reported, never resumed.
+- A user's goal is reported once as `left yours alone` and is never resumed, cleared, paused or overwritten. The `/goal <objective>` command replaces an existing goal without asking, so LitOpenCode reads before every create and treats an unreadable state as a conflict, not as "no goal".
+- Every change prints one line that starts with `LitOpenCode goal:` and is recorded in the ledger (`native-goal.created`, `.resumed`, `.cleared`, `.left-alone`, `.conflict`, `.failed`, `.unavailable`).
+- A failed `/goal` call is recorded and the work continues on the ledger alone.
 
-- Do not infer host goal support from naming similarity alone.
-- Keep the public README aligned with the verified host capability.
-- If native support appears in a future host version, add a new feature binding and a migration note before changing runtime behavior.
+## Hosts without `/goal`
 
-## Why the Verdict Matters
+OpenCode 1 and OpenCode 2 builds without the `opencode.goal` RPC record `native-goal-unavailable` once per session and route, set nothing, and keep today's behaviour. Do not fake a goal, and do not tell the user one exists. The `litgoal` skill and its ledger work the same everywhere.
 
-Goal behavior is central to LitOpenCode’s identity, but the implementation must match the host surface that actually exists. If OpenCode exposes a native goal primitive in a future release, LitOpenCode can consider binding to it. Until then, the package should not promise that `/goal` or any host-owned goal state exists. Overclaiming native support would mislead users, break tests, and make durable state migration unsafe.
+## Verification Route
 
-The current verdict is intentionally conservative: local evidence has not shown a native OpenCode goal primitive through the CLI command list or the `@opencode-ai/plugin` hooks type surface. Therefore LitOpenCode owns its goal state under `.litopencode/litgoal`. This package-owned ledger is not a second-class fallback; it is the verified implementation path for resumable work, evidence checkpoints, and recap continuity.
+- On OpenCode 2, run `opencode2` (it installs beside `opencode`) in a temporary project and watch the `LitOpenCode goal:` lines for `lit-loop`, a user-typed `/goal` first, and `lit plan`.
+- On OpenCode 1, run `lit-loop` in the same project and expect `native-goal-unavailable` in `.litopencode/litgoal/lit-loop/ledger.jsonl`.
+- Run `node --test test/v2-native-goal.test.mjs test/v2-native-goal-wiring.test.mjs test/native-goal-v1.test.mjs`.
+- Run `node --test test/runtime-skills.test.mjs` and `node --test test/docs.test.mjs`.
 
 ## Evidence Standard for Changing the Verdict
 
-Changing the verdict requires current host evidence. Acceptable evidence includes official OpenCode documentation for a goal primitive, local CLI help that lists a goal command or goal API, plugin type definitions that expose goal hooks or goal storage, and working integration tests that prove the behavior. Naming similarity, user memory, old screenshots, or another product’s goal feature are not enough.
-
-The evidence should be captured in tests or docs. If a future OpenCode release adds native goals, add a feature binding, migration docs, runtime tests, and compatibility behavior before changing public claims. The migration should explain what happens to existing `.litopencode/litgoal` state, whether state is copied, read-only migrated, or left as historical evidence, and how users can verify the change.
+The verdict rests on the merged OpenCode sources (the goal plugin, the `Goal` schema and `SessionApi.command`), the published `@opencode/plugin` 2.2.5 types, and a run on a real 2.2.5 host. A later host release changes the details, so record the OpenCode version, the package version and what the RPC returned before changing any claim. Naming similarity, memory, old screenshots or another product's goal feature are not evidence.
 
 ## Package-Owned Ledger Behavior
 
-Because native host support is not verified, LitOpenCode uses package-owned durable state. The state path `.litopencode/litgoal` is local to the project and should stay out of package payload and commits unless a future task explicitly changes that design. Tool and command surfaces such as `lit`, `litwork`, `start-work`, and `review-work` can read or write ledger events through the package’s own implementation. Recap can read ledger state without writing it. Static skills can document the state but do not execute it.
-
-This design keeps behavior testable. Ledger tests can cover JSONL append, recovery, malformed lines, redaction, and status reads. Docs tests can ensure the verdict remains visible. Pack payload tests can ensure local state is excluded. Reviewers can reason about the exact path and event model rather than relying on an unspecified host feature.
+The state path `.litopencode/litgoal` is local to the project and stays out of the package payload and commits. `lit`, `litwork`, `start-work` and `review-work` read and write ledger events through the package's own implementation; recap reads without writing. The ledger tests cover JSONL append, recovery, malformed lines, redaction and status reads, and the native-goal tests cover the ownership records on top of them.
 
 ## Wording Rules
 
-Use precise language: “OpenCode host surface does not currently expose a native goal primitive” and “LitOpenCode uses `.litopencode/litgoal`.” Avoid phrases that imply a hidden binding, such as “uses OpenCode goals internally,” unless future evidence proves it. Avoid promising `/goal` behavior. Avoid saying “native goal support is impossible”; host capabilities can change. The right statement is current, evidence-bound, and revisable.
-
-Public docs should align with this verdict. If README, release checklist, runtime skill docs, and command prompts disagree, users will not know which state is authoritative. When updating one surface, search for related wording and run docs tests. Do not introduce old host terms or sibling product terms while explaining the verdict.
+Say "OpenCode 2.2 and later has a native `/goal`" and "LitOpenCode sets it only for lit-loop, start-work and litwork". Say "OpenCode 1 has none" for older hosts. Do not say LitOpenCode "uses OpenCode goals internally" for read-only routes, do not promise `/goal` on OpenCode 1, and do not describe the ledger as a second-class fallback: it is the second half of "done" on every host.
 
 ## OpenCode Surface Checks
 
-The verification route should inspect the host from two directions. The CLI command list shows what a user can invoke. The plugin hooks type shows what a plugin can observe or extend. Both matter. A CLI command without a plugin API may not support LitOpenCode integration. A type name without a runtime command may not be user-visible. If either surface changes, tests should capture the new supported path.
-
-Be careful with installed versions. A global OpenCode CLI may differ from the package used in local tests. A lockfile may point at one plugin version while the user runtime uses another. Record versions when re-evaluating the verdict. If evidence is ambiguous, keep the conservative ledger path and state uncertainty.
+The goal surface has three parts: the `opencode.goal` RPC to read, the `/goal` command through `session.command` to change, and the `experimental.idle` session hook, which runs when a session finishes its work and is where LitOpenCode checks a finished goal. `@opencode/plugin` 2.2.5 types all three; the older 2.0.x types do not. A global `opencode2` may differ from the version in the lockfile, so record both when re-checking.
 
 ## Review Checklist
 
-- Does the doc say current host surface lacks verified native goal support?
-- Does it name `.litopencode/litgoal` as package-owned state?
-- Does it avoid claiming direct host goal binding?
-- Do tests cover runtime skill visibility and docs wording?
-- Do package guards exclude local ledger state?
-- If future native support is claimed, is there official or local host evidence and a migration plan?
+- Does a user-made goal stay untouched, including on idle?
+- Is a goal created only when none exists, and only on the three routes?
+- Is "done" reported only when OpenCode's verdict and the ledger agree?
+- Does a host without `/goal` record `native-goal-unavailable` and nothing else?
+- Is there a bounded number of resumes, and no resume of a goal the user or the round limit paused?
+- Does every change print one `LitOpenCode goal:` line?
 
 ## Failure Modes
 
-One failure mode is optimistic wording after a host release note mentions goals but before plugin integration is tested. Another is copying goal language from a different product with a different host model. Another is treating durable ledger state as if it were a host feature, which can confuse users about where files live and what gets packed. Another is hiding the verdict in a release note while command prompts still imply native support. The static skill exists to keep the conservative evidence-bound verdict easy to find.
+A create over a goal the user just made (the command overwrites). A resume of a goal the user paused, which fights the user. A clear when only OpenCode's reviewer said done, which hides an open ledger. Repeated notices on every idle turn. A read failure treated as "no goal". Treating `/lit` and `/lit-loop` as different when the installed command files share one body. Each has a test in `test/v2-native-goal.test.mjs` or `test/v2-native-goal-wiring.test.mjs`.
 
 ## Completion Claims Involving Goals
 
-When work touches goal behavior, DoneClaims should say whether the change affected package-owned ledger behavior, host command activation, static docs, or only wording. Include tests such as goal tests, runtime skills tests, docs tests, and pack payload checks when relevant. If no host native goal support was re-verified, do not make new host-goal claims. If local ledger files were created during tests, clean them up or state that they are ignored evidence.
-
-## Migration Thought Experiment
-
-If OpenCode later exposes native goals, do not immediately delete the package ledger. First, design compatibility. Existing projects may have `.litopencode/litgoal` history that powers recap and review. Users may depend on local evidence paths. A migration might read both native and package state, export old events, or keep package state for historical sessions while new sessions use host storage. Each option needs tests, docs, and rollback.
-
-The migration plan should answer: what is the source of truth after upgrade; how are duplicate goals reconciled; how are secrets protected; what happens in older OpenCode versions; how does package payload avoid local state; how does `/lit-recap` read history; and how does `start-work` find approved plans? Until those answers exist, the conservative ledger path remains safer.
+A DoneClaim for goal work says which host it ran on, which routes set a goal, what happened to a user-made goal, and that the ledger and OpenCode's verdict both closed. Include the native-goal tests, the docs and runtime-skills tests, the pack payload check, and a real-surface run. If only OpenCode 1 was available, say the OpenCode 2 path was not exercised.
 
 ## Support Triage
 
-When a user asks “where is my goal,” first clarify whether they mean LitOpenCode durable state or a host feature. Ask for package version, OpenCode version, project root, and whether `.litopencode/litgoal` exists. Do not tell them to run destructive cleanup. If state is missing, check whether they are in a different worktree or package root. If state is malformed, preserve the file before repair. If the user expects host-native behavior, explain the current verdict and package-owned path.
+When someone asks "where is my goal", ask whether they mean OpenCode's `/goal` or LitOpenCode's ledger. `/goal` with no text prints the host goal; `lit adhd` and `litwork action=status` print the ledger. A `LitOpenCode goal: conflict` line means OpenCode and the ledger disagree: finish the ledger criteria, or clear the host goal yourself if the work is abandoned. Do not tell anyone to delete `.litopencode/litgoal`.
 
 ## Documentation Consistency
 
-Every public mention of goal behavior should match three facts: current host native support is not verified; LitOpenCode uses package-owned durable state; future host support would require a tested migration. If one document drifts, update it and run docs tests. Avoid mixing “goal,” “ledger,” and “recap” as if they were the same feature. The ledger stores durable events, recap summarizes evidence, and goal behavior coordinates work.
-
-## Test Ideas for Future Host Changes
-
-If host support appears, add tests that prove both old and new paths. A compatibility test should read an existing `.litopencode/litgoal` fixture and verify it is not lost. A host-integration test should prove the OpenCode goal surface can be detected without guessing. A command test should prove `litwork`, `/start-work`, and `/review-work` use the correct source of truth. A pack test should prove local goal state still does not ship. A docs test should prove wording changed from conservative ledger language to the new verified integration language only after evidence exists.
-
-## User Communication
-
-Users do not need an implementation lecture every time. For normal use, say where state lives and how to inspect it. For capability questions, say the current verdict and evidence. For migration questions, say that package-owned state remains authoritative until a tested migration exists. Avoid blaming the host or promising future behavior. The goal is clear expectations.
-
-## Decision Log Guidance
-
-When re-evaluating native goal support, record the decision like an engineering verdict: date, OpenCode version, package version, CLI evidence, plugin type evidence, tests run, and conclusion. If the conclusion remains “not exposed,” keep runtime behavior unchanged. If the conclusion changes, open a plan for migration rather than mixing discovery and implementation. This avoids accidental drift where one doc claims native support while code still uses the package ledger.
-
-## Compatibility Language
-
-Compatibility docs should say that `.litopencode/litgoal` is stable local state for current LitOpenCode workflows. If future host integration arrives, compatibility will be documented and tested. Do not tell users to delete ledger state to prepare for a hypothetical migration. Do not tell users that host goals and package goals are interchangeable until code proves synchronization or conversion.
+Every public mention of goals matches four facts: OpenCode 2.2 and later has `/goal`; LitOpenCode sets one only for lit-loop, start-work and litwork; a user's goal is never touched; the ledger stays the evidence record and the second half of done. Keep README, `docs/reference.md`, the litgoal and lit-loop skills, the lit-loop activation prompt and the release checklist in step, and run the docs tests after any change.

package/skills/start-work/SKILL.md

@@ -340,3 +340,7 @@ in your first response and continue with the one that injected you.
 It says nothing about how to execute — the sections above own that. Its only job is to answer three
 questions a skill body cannot answer for itself: how was I reached, have I already been reached, and
 whose contract am I under.
+
+## Native goal on OpenCode 2
+
+On OpenCode 2.2 and later, start-work gets a native `/goal` from LitOpenCode itself, set once when none exists and carrying the approved plan's completion conditions. A goal the user made is reported and left alone, and a host without `/goal` records `native-goal-unavailable`. The goal never widens the run's authority: scope roots, grants and the bounded-authority journal decide what the work may touch. Done needs OpenCode's verdict and the ledger together. See `native-goal-verdict`.

package/skills/workflow-loop/SKILL.md

@@ -389,3 +389,7 @@ a smaller task only if the deliverable is still required.
 
 A child's own done-claim is a claim, not verification. Silence is not failure and it is not success;
 it is absence of signal, and it must be recorded as such.
+
+## Native goal on OpenCode 2
+
+On OpenCode 2.2 and later, lit-loop gets a native `/goal` from LitOpenCode itself: it is set when none exists, carries the completion conditions of this ledger, and is resumed or cleared only when LitOpenCode created it. Do not type `/goal` for the user, and leave a goal the user made alone; the `LitOpenCode goal:` line reports what happened. A host without `/goal` records `native-goal-unavailable` and the ledger carries the loop. Done needs both OpenCode's verdict and the ledger, so never report done while a criterion, the real-surface check or the cleanup receipt is open. See `native-goal-verdict`.