@litfamily/litopencode 1.0.35 → 1.0.37

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/dist/v2/tui-notices.d.ts

@@ -0,0 +1,7 @@
+import { type MissionNotice, type MissionView } from "../tui/mission-model.ts";
+import type { ThreadRow } from "../tui/mission-threads.ts";
+/**
+ * Stage, discipline and lane changes between two views. A first view never toasts its history. A lane
+ * counts as started when its key is new and working, and as finished when a working lane is gone or done.
+ */
+export declare function v2StageNotices(prev: MissionView | undefined, next: MissionView, before: readonly ThreadRow[], after: readonly ThreadRow[]): readonly MissionNotice[];

package/dist/v2/tui-notices.js

@@ -0,0 +1,45 @@
+// The toasts OpenCode 2 raises beyond the shared gate events (plan saved, goal set, criterion passed,
+// blockers, complete): the workflow stage moving, a discipline switching, a lane starting or finishing.
+// They are pure: the TUI hands in the previous and next view and thread rows and gets notices back,
+// which leadingNotice folds into one toast with a `+N more` tail.
+import { stepName } from "../tui/mission-model.js";
+const maxNamed = 1;
+function runningStage(view) {
+    const step = view.steps.find((candidate) => candidate.state === "now");
+    if (step === undefined)
+        return undefined;
+    const count = view.progress !== undefined && view.progress.total > 0 ? ` ${view.progress.done}/${view.progress.total}` : "";
+    return { id: `${view.family}:${step.id}`, label: `${stepName(step.id, view)}${count}` };
+}
+function laneNotice(rows, verb) {
+    if (rows.length === 0)
+        return undefined;
+    const message = rows.length > maxNamed ? `${rows.length} lanes ${verb}` : `lane ${verb} · ${rows[0].name}`;
+    return { variant: "info", title: "🔥 Lane", message };
+}
+/**
+ * Stage, discipline and lane changes between two views. A first view never toasts its history. A lane
+ * counts as started when its key is new and working, and as finished when a working lane is gone or done.
+ */
+export function v2StageNotices(prev, next, before, after) {
+    if (prev === undefined || !next.active)
+        return [];
+    const notices = [];
+    if (prev.active && prev.discipline !== next.discipline && next.discipline !== "") {
+        notices.push({ variant: "info", title: `🔥 ${prev.discipline} → ${next.discipline}`, message: "Discipline switched." });
+    }
+    else if (prev.active && !next.complete) {
+        const was = runningStage(prev);
+        const now = runningStage(next);
+        if (was !== undefined && now !== undefined && was.id !== now.id)
+            notices.push({ variant: "info", title: "🔥 Stage", message: now.label });
+    }
+    const priorKeys = new Set(before.map((row) => row.key));
+    const nextByKey = new Map(after.map((row) => [row.key, row]));
+    const started = after.filter((row) => row.status === "working" && !priorKeys.has(row.key));
+    const finished = before.filter((row) => row.status === "working" && (nextByKey.get(row.key) === undefined || nextByKey.get(row.key)?.status === "done"));
+    for (const notice of [laneNotice(started, "started"), laneNotice(finished, "finished")])
+        if (notice !== undefined)
+            notices.push(notice);
+    return notices;
+}

package/dist/v2/tui.d.ts

@@ -5,6 +5,11 @@ export type TuiRuntime = {
     readonly createSignal: <T>(value: T) => readonly [() => T, (value: T) => T];
     readonly createEffect: (fn: () => void) => void;
     readonly createRoot: <T>(fn: (dispose: () => void) => T) => T;
+    /** The host's terminal size, reactive; a stand-in runtime may leave it out. */
+    readonly useTerminalDimensions?: () => () => {
+        readonly width: number;
+        readonly height: number;
+    };
 };
 type PromptFooterInput = {
     readonly sessionID?: string;
@@ -19,15 +24,38 @@ export type SlotClaimLike = {
 } | {
     readonly append: "prompt.footer.status";
     readonly render: (input: PromptFooterInput) => unknown;
+} | {
+    readonly append: "app";
+    readonly render: (input: Record<string, never>) => unknown;
+} | {
+    readonly append: "home.footer";
+    readonly render: (input: Record<string, never>) => unknown;
 };
 export type TuiContextLike = {
+    readonly options?: unknown;
     readonly location: {
         readonly directory: string;
     } | undefined;
     readonly theme: unknown;
     readonly themeMode: "dark" | "light";
+    readonly attention?: {
+        readonly notify: (options: {
+            readonly title?: string;
+            readonly message: string;
+            readonly notification?: boolean;
+            readonly sound?: boolean | {
+                readonly name?: "done";
+            };
+        }) => Promise<unknown>;
+    };
     readonly ui: {
         readonly slot: (claim: SlotClaimLike) => () => void;
+        readonly router?: {
+            current(): {
+                readonly type: string;
+                readonly sessionID?: string;
+            };
+        };
         readonly toast: {
             readonly show: (options: {
                 readonly title?: string;
@@ -49,11 +77,19 @@ export type TuiContextLike = {
                 readonly type: string;
             };
         }) => void) => () => void;
-        readonly location: {
+        readonly location: MissionDataV2["location"] & {
             default(): {
                 readonly directory: string;
             };
         };
+        readonly session: MissionDataV2["session"] & {
+            get?(sessionID: string): {
+                readonly parentID?: string;
+                readonly time?: {
+                    readonly created?: number;
+                };
+            } | undefined;
+        };
     };
 };
 /** OpenCode 2 theme tokens under the names the mission palette reads. */