@litfamily/litopencode 1.0.28 → 1.0.30

package/dist/v2/events.js

@@ -0,0 +1,193 @@
+import { createAutoHandoff } from "../auto-handoff-hooks.js";
+import { LifecycleConflictError, LifecycleSafetyError, createBoundedAuthorityLifecycle, parseFencedProgress } from "../bounded-authority.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function str(value) {
+    return typeof value === "string" && value !== "" ? value : undefined;
+}
+/**
+ * The calls the OpenCode 1 automatic handoff makes, answered by OpenCode 2. There is no server toast on
+ * OpenCode 2, so the client has no `tui`; the handoff's own notices are not shown there.
+ */
+function handoffClient(session, model, statuses) {
+    const client = {
+        session: {
+            async promptAsync(input) {
+                const text = [input.body.system, ...(input.body.parts ?? []).map((part) => part.text)].filter((part) => typeof part === "string" && part !== "").join("\n\n");
+                await session.prompt({ sessionID: input.path.id, text });
+                return { data: {} };
+            },
+            async summarize(input) {
+                await session.compact({ sessionID: input.path.id });
+                return { data: true };
+            },
+            async status() {
+                return { data: Object.fromEntries(statuses) };
+            }
+        },
+        config: {
+            async providers() {
+                const listed = await model.list();
+                const models = Array.isArray(listed) ? listed : listed.data;
+                const providers = new Map();
+                for (const entry of models) {
+                    const byId = providers.get(entry.providerID) ?? {};
+                    byId[entry.modelID ?? entry.id] = { limit: entry.limit };
+                    providers.set(entry.providerID, byId);
+                }
+                return { data: { providers: [...providers].map(([id, models]) => ({ id, models })) } };
+            }
+        }
+    };
+    return client;
+}
+export function createV2Events(options) {
+    const statuses = new Map();
+    const steps = new Map();
+    const lifecycle = createBoundedAuthorityLifecycle(options.projectRoot, options.boundedAuthority);
+    const autoHandoff = createAutoHandoff({
+        projectRoot: options.projectRoot,
+        paths: options.paths,
+        client: handoffClient(options.session, options.model, statuses),
+        config: options.autoHandoffConfig,
+        getSession: options.getSession
+    });
+    // Translated into the OpenCode 1 event shapes the handoff state machine reads.
+    async function toHandoff(type, properties) {
+        await autoHandoff.event({ event: { type, properties } });
+    }
+    async function recordProgress(sessionID, messageID, ordinal, text) {
+        let progress;
+        try {
+            progress = parseFencedProgress(text);
+        }
+        catch {
+            return;
+        }
+        if (progress === undefined)
+            return;
+        const partID = `${messageID}:text:${ordinal}`;
+        try {
+            const recorded = await lifecycle.recordProgress({ ...progress, sessionID, messageID, partID });
+            if (recorded.dispatchRequired !== true || recorded.continuation === undefined || recorded.continuationMessageID === undefined)
+                return;
+            try {
+                // The id is the host's dedupe key: a replayed text end admits the same message, not a second one.
+                await options.session.prompt({ sessionID, text: recorded.continuation, id: recorded.continuationMessageID });
+            }
+            catch {
+                return;
+            }
+            await lifecycle.markContinuationSent({ workId: recorded.state.workId, sessionID: recorded.state.sessionID, revision: recorded.state.revision, messageID, partID });
+        }
+        catch (error) {
+            if (error instanceof LifecycleConflictError || error instanceof LifecycleSafetyError)
+                return;
+            throw error;
+        }
+    }
+    async function handle(event) {
+        const data = isRecord(event.data) ? event.data : {};
+        const sessionID = str(data.sessionID);
+        if (sessionID === undefined)
+            return;
+        switch (event.type) {
+            case "session.deleted":
+                statuses.delete(sessionID);
+                // A step cut short (abort, crash) never ends; its entry goes with its session.
+                for (const [messageID, step] of steps)
+                    if (step.sessionID === sessionID)
+                        steps.delete(messageID);
+                options.onSessionDeleted(sessionID);
+                await toHandoff("session.deleted", { info: { id: sessionID } });
+                return;
+            case "session.step.started": {
+                const messageID = str(data.assistantMessageID);
+                const model = isRecord(data.model) ? data.model : {};
+                const providerID = str(model.providerID);
+                const modelID = str(model.id);
+                if (messageID === undefined || providerID === undefined || modelID === undefined)
+                    return;
+                steps.set(messageID, { sessionID, providerID, modelID, ...(str(data.agent) === undefined ? {} : { agent: str(data.agent) }), started: typeof data.started === "number" ? data.started : Date.now() });
+                return;
+            }
+            case "session.step.ended": {
+                const messageID = str(data.assistantMessageID);
+                const step = messageID === undefined ? undefined : steps.get(messageID);
+                if (messageID === undefined || step === undefined)
+                    return;
+                steps.delete(messageID);
+                await toHandoff("message.updated", {
+                    info: {
+                        id: messageID,
+                        role: "assistant",
+                        sessionID,
+                        providerID: step.providerID,
+                        modelID: step.modelID,
+                        ...(step.agent === undefined ? {} : { mode: step.agent }),
+                        tokens: data.tokens,
+                        time: { created: step.started },
+                        ...(data.finish === "error" ? { error: { name: "StepError" } } : {})
+                    }
+                });
+                return;
+            }
+            case "session.status":
+                statuses.set(sessionID, data.status);
+                await toHandoff("session.status", { sessionID, status: data.status });
+                return;
+            case "session.idle":
+                await toHandoff("session.idle", { sessionID });
+                return;
+            case "session.compaction.ended":
+                await toHandoff("session.compacted", { sessionID });
+                return;
+            case "session.text.ended": {
+                const messageID = str(data.assistantMessageID);
+                if (messageID === undefined || typeof data.text !== "string")
+                    return;
+                await recordProgress(sessionID, messageID, typeof data.ordinal === "number" ? data.ordinal : 0, data.text);
+                return;
+            }
+            default:
+                return;
+        }
+    }
+    /** Reads the stream until stopped. A failing handler never ends the subscription. */
+    function start(events) {
+        const controller = new AbortController();
+        const loop = (async () => {
+            try {
+                for await (const event of events.subscribe({ signal: controller.signal })) {
+                    if (controller.signal.aborted)
+                        break;
+                    try {
+                        await handle(event);
+                    }
+                    catch { // no-excuse-ok: catch -- one bad event must not stop the plugin from reading the rest.
+                    }
+                }
+            }
+            catch { // no-excuse-ok: catch -- the stream closes with an error when the instance stops.
+            }
+        })();
+        return async () => {
+            controller.abort();
+            await loop;
+        };
+    }
+    return {
+        handle,
+        start,
+        /** Steps started and not yet ended. */
+        pendingSteps: () => steps.size,
+        route: autoHandoff.route,
+        /** The saved handoff, handed back once after a compaction. */
+        async systemText(sessionID) {
+            const output = { system: [] };
+            await autoHandoff.systemTransform({ sessionID }, output);
+            return output.system;
+        }
+    };
+}

package/dist/v2/hooks.d.ts

@@ -0,0 +1,39 @@
+import type { DeliverableHedgeGuardState } from "../deliverable-hedge-guard.ts";
+import type { SessionLookup } from "../session-lineage.ts";
+export type ToolBeforeEvent = {
+    tool: string;
+    readonly sessionID: string;
+    readonly agent: string;
+    readonly messageID: string;
+    readonly id: string;
+    input: unknown;
+};
+type ToolContent = string | ReadonlyArray<{
+    readonly type: string;
+    readonly text?: string;
+}>;
+export type ToolAfterEvent = {
+    readonly tool: string;
+    readonly sessionID: string;
+    readonly agent: string;
+    readonly messageID: string;
+    readonly id: string;
+    readonly input: unknown;
+    readonly status: "completed" | "error";
+    result?: {
+        content?: ToolContent;
+        metadata?: Readonly<Record<string, unknown>>;
+        output?: unknown;
+    };
+};
+export type V2ToolHookOptions = {
+    readonly projectRoot: string;
+    readonly knowledgeCaptureEnabled: boolean;
+    readonly getSession: SessionLookup;
+    readonly deliverableHedgeGuard: DeliverableHedgeGuardState;
+};
+export declare function createV2ToolHooks(options: V2ToolHookOptions): {
+    executeBefore: (event: ToolBeforeEvent) => Promise<void>;
+    executeAfter: (event: ToolAfterEvent) => Promise<void>;
+};
+export {};

package/dist/v2/hooks.js

@@ -0,0 +1,61 @@
+// Tool hooks on OpenCode 2, reusing the OpenCode 1 guards. OpenCode 2 renamed two tools (bash is shell,
+// task is subagent) and names a file argument `path`, so each call is shown to the guards under the
+// names they know. A throw in `execute.before` fails that one call; `execute.after` must never throw.
+import { createToolExecuteAfterHook, createToolExecuteBeforeHook } from "../hooks.js";
+const v1ToolNames = { shell: "bash", subagent: "task" };
+function v1ToolName(tool) {
+    return v1ToolNames[tool] ?? tool;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** The arguments as the OpenCode 1 guards read them: a `path` also answers to `filePath`. */
+function v1Args(input) {
+    if (!isRecord(input) || typeof input.path !== "string" || "filePath" in input)
+        return { args: input, aliased: false };
+    return { args: { ...input, filePath: input.path }, aliased: true };
+}
+function contentText(content) {
+    if (content === undefined)
+        return "";
+    if (typeof content === "string")
+        return content;
+    return undefined;
+}
+export function createV2ToolHooks(options) {
+    const before = createToolExecuteBeforeHook({ getSession: options.getSession, deliverableHedgeGuard: options.deliverableHedgeGuard });
+    const after = createToolExecuteAfterHook({
+        projectRoot: options.projectRoot,
+        knowledgeCaptureEnabled: options.knowledgeCaptureEnabled,
+        deliverableHedgeGuard: options.deliverableHedgeGuard
+    });
+    async function executeBefore(event) {
+        const { args, aliased } = v1Args(event.input);
+        const output = { args };
+        await before({ tool: v1ToolName(event.tool), sessionID: event.sessionID, callID: event.id }, output);
+        if (output.args === args)
+            return;
+        if (aliased && isRecord(output.args)) {
+            const { filePath: _alias, ...rest } = output.args;
+            event.input = rest;
+            return;
+        }
+        event.input = output.args;
+    }
+    async function executeAfter(event) {
+        if (event.status !== "completed" || event.result === undefined)
+            return;
+        const text = contentText(event.result.content);
+        if (text === undefined)
+            return;
+        const output = { title: "", output: text, metadata: { ...(event.result.metadata ?? {}) } };
+        try {
+            await after({ tool: v1ToolName(event.tool), sessionID: event.sessionID, callID: event.id, args: v1Args(event.input).args }, output);
+        }
+        catch { // no-excuse-ok: catch -- OpenCode 2 treats a throw after a tool ran as a crash; the result stays as it was.
+            return;
+        }
+        event.result = { ...event.result, content: output.output, metadata: output.metadata };
+    }
+    return { executeBefore, executeAfter };
+}

package/dist/v2/server.d.ts

@@ -0,0 +1,2 @@
+import { type ServerContextLike } from "./context.ts";
+export declare function setupLitOpenCodeServer(context: ServerContextLike): Promise<() => Promise<void>>;

package/dist/v2/server.js

@@ -0,0 +1,68 @@
+// LitOpenCode's OpenCode 2 server plugin. OpenCode 2 runs one instance per project location and calls
+// `setup` once for it; every registration below is released by the host when the instance stops, and
+// the returned cleanup releases what the plugin itself holds. There is no automatic self-update here:
+// OpenCode 2 updates plugins itself (`opencode plugin update` and its update policy).
+import path from "node:path";
+import { loadConfig } from "../config.js";
+import { createDeliverableHedgeGuard } from "../deliverable-hedge-guard.js";
+import { createLogger } from "../logger.js";
+import { defaultOpenCodeConfigRoot } from "../state.js";
+import { applyLitAgents, createSessionModelRoute, enforcePlanningOnly, planLitAgents, registerOpenAiProviderModels } from "./agents.js";
+import { createSessionLookupV2, projectRootFromLocation } from "./context.js";
+import { createV2Commands } from "./commands.js";
+import { createV2Events } from "./events.js";
+import { createV2ToolHooks } from "./hooks.js";
+import { createV2SessionHooks } from "./session-hooks.js";
+import { addLitTools, litToolsForProject } from "./tools.js";
+export async function setupLitOpenCodeServer(context) {
+    const root = projectRootFromLocation(context.location);
+    const loaded = await loadConfig(root);
+    const logger = createLogger(loaded.paths);
+    const getSession = createSessionLookupV2(context.session);
+    const deliverableHedgeGuard = createDeliverableHedgeGuard({ projectRoot: context.location.directory.trim() || root });
+    const agentPlan = planLitAgents(loaded.config);
+    const toolHooks = createV2ToolHooks({
+        projectRoot: root,
+        knowledgeCaptureEnabled: loaded.config.knowledge.capture,
+        getSession,
+        deliverableHedgeGuard
+    });
+    await context.model.transform(registerOpenAiProviderModels);
+    await context.agent.transform((editor) => applyLitAgents(editor, agentPlan));
+    await context.permission.hook("evaluate", enforcePlanningOnly);
+    const tools = litToolsForProject(root);
+    await context.tool.transform((editor) => addLitTools(editor, tools));
+    await context.tool.hook("execute.before", toolHooks.executeBefore);
+    await context.tool.hook("execute.after", toolHooks.executeAfter);
+    const commands = createV2Commands([defaultOpenCodeConfigRoot(), path.join(root, ".opencode")], context.session);
+    await context.command.transform((editor) => commands.add(editor));
+    const events = createV2Events({
+        projectRoot: root,
+        paths: loaded.paths,
+        autoHandoffConfig: loaded.config.autoHandoff,
+        boundedAuthority: loaded.config.boundedAuthority,
+        getSession,
+        session: context.session,
+        model: context.model,
+        onSessionDeleted: (sessionID) => sessionHooks.clear(sessionID)
+    });
+    const sessionHooks = createV2SessionHooks({
+        projectRoot: root,
+        config: loaded.config,
+        getSession,
+        routeModel: createSessionModelRoute(agentPlan, context.session, context.model),
+        requestOptions: agentPlan.requestOptions,
+        autoHandoffRoute: events.route,
+        extraSystem: events.systemText,
+        acceptCommandMark: commands.acceptMark
+    });
+    await context.session.hook("prompt", sessionHooks.prompt);
+    await context.session.hook("context", sessionHooks.context);
+    await context.session.hook("compaction", sessionHooks.compaction);
+    const stopEvents = events.start(context.event);
+    return async () => {
+        await stopEvents();
+        deliverableHedgeGuard.dispose();
+        await logger.dispose();
+    };
+}

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

@@ -0,0 +1,64 @@
+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";
+export type SystemPartLike = {
+    readonly type: "text";
+    readonly text: string;
+};
+export type PromptEvent = {
+    readonly sessionID: string;
+    readonly messageID: string;
+    prompt: {
+        text: string;
+    };
+    metadata?: Record<string, unknown>;
+};
+/** An OpenCode 2 request message: an instance of the host's own message class. */
+export type MessageLike = {
+    readonly role: string;
+    readonly content: readonly unknown[];
+};
+export type ContextEvent = {
+    readonly sessionID: string;
+    readonly agent: string;
+    system: SystemPartLike[];
+    messages?: MessageLike[];
+    options: Record<string, unknown>;
+};
+export type SessionAgentLookup = (sessionID: string) => Promise<{
+    readonly parentID?: string;
+    readonly agent?: string;
+} | undefined>;
+export type V2SessionHookOptions = {
+    readonly projectRoot: string;
+    readonly config: Pick<LitOpenCodeConfig, "outputStyle" | "boundedAuthority">;
+    readonly getSession: SessionAgentLookup;
+    /** Puts a session that has no model of its own on its agent's route. */
+    readonly routeModel?: (sessionID: string) => Promise<void>;
+    readonly requestOptions: ReadonlyMap<string, AgentRequestOptions>;
+    readonly autoHandoffRoute?: (text: string, mode: AutoHandoffRouteMode) => Promise<string | undefined>;
+    /** Extra system text for this request, such as the saved handoff after a compaction. */
+    readonly extraSystem?: (sessionID: string) => Promise<readonly string[]>;
+    readonly onActivation?: (sessionID: string, mode: ChatActivationMode | string) => void;
+    /** Accepts a command mark the plugin itself sent for this session; anything else is dropped. */
+    readonly acceptCommandMark?: (sessionID: string, marker: unknown) => {
+        readonly command: string;
+        readonly banner: string;
+    } | undefined;
+};
+/**
+ * `opencode2 run "lit fix it"` sends the message wrapped in double quotes (each multi-word argument is
+ * quoted, inner quotes escaped). The prompt hook runs in the server, so the run's argv is not available
+ * the way it is on OpenCode 1; a message that is exactly one such quoted argument is read without the
+ * quotes. Quoted text inside a longer prompt stays inactive. The server cannot tell a run argument from
+ * a TUI prompt typed entirely inside double quotes, so such a typed `"lit fix it"` activates as well;
+ * on OpenCode 1 it stayed inert.
+ */
+export declare function unwrapRunArgument(input: string): string;
+export declare function createV2SessionHooks(options: V2SessionHookOptions): {
+    prompt: (event: PromptEvent) => Promise<void>;
+    context: (event: ContextEvent) => Promise<void>;
+    compaction: (event: ContextEvent) => Promise<void>;
+    clear(sessionID: string): void;
+};

package/dist/v2/session-hooks.js

@@ -0,0 +1,230 @@
+// Prompt admission and request context on OpenCode 2. OpenCode 1 appended activation text to the user
+// message as an extra part; OpenCode 2 has no parts. Here the `prompt` hook marks a lit prompt in the
+// user message metadata (which the TUI reads for the ignition toast and the footer line), and the
+// `context` hook hands the activation text, the static rules and the reader contract to every model
+// request of that session as system parts. Text that comes from the project or a lifecycle file rather
+// than from LitOpenCode's own instructions (local knowledge, a start-work receipt, an auto-handoff setting
+// reply) rides the latest user message instead, the channel it had on OpenCode 1.
+import { fileURLToPath } from "node:url";
+import { createActivationMemory, decideReentry } from "../activation-reentry.js";
+import { detectChatActivationMode, promptForChatActivationMode } from "../activation-routing.js";
+import { startWorkPromptInjection } from "../activation-workflow-prompts.js";
+import { autoHandoffSettingText } from "../auto-handoff.js";
+import { applyTrustedStartWorkDirective, parseStartWorkLifecycleDirective } from "../bounded-authority-hooks.js";
+import { queryKnowledge } from "../knowledge.js";
+import { createLitGoalOperations } from "../ledger.js";
+import { applyCompactionRuleReset, applyStaticRuleInjection } from "../rules/hooks.js";
+import { isReadOnlyWorkflowFamilyPlan } from "../workflow-families.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
+ * quoted, inner quotes escaped). The prompt hook runs in the server, so the run's argv is not available
+ * the way it is on OpenCode 1; a message that is exactly one such quoted argument is read without the
+ * quotes. Quoted text inside a longer prompt stays inactive. The server cannot tell a run argument from
+ * a TUI prompt typed entirely inside double quotes, so such a typed `"lit fix it"` activates as well;
+ * on OpenCode 1 it stayed inert.
+ */
+export function unwrapRunArgument(input) {
+    const match = /^"((?:[^"\\]|\\.)*)"$/su.exec(input);
+    return match === null ? input : match[1].replace(/\\"/gu, '"');
+}
+function text(value) {
+    return { type: "text", text: value };
+}
+/**
+ * Adds text parts to the latest user message. The host builds each message with its own class, so the
+ * copy is made with that class; false when there is no user message to carry the text.
+ */
+function appendToLatestUserMessage(messages, texts) {
+    if (messages === undefined)
+        return false;
+    let index = messages.length - 1;
+    while (index >= 0 && messages[index].role !== "user")
+        index -= 1;
+    if (index < 0)
+        return false;
+    const latest = messages[index];
+    const Message = latest.constructor;
+    messages[index] = new Message({ ...latest, content: [...latest.content, ...texts.map(text)] });
+    return true;
+}
+export function createV2SessionHooks(options) {
+    const operations = createLitGoalOperations(options.projectRoot);
+    const sessions = new Map();
+    // The latest activation stays in every request of its session, so a repeated lit only adds a note to it.
+    const activationMemory = createActivationMemory();
+    function stateFor(sessionID) {
+        let state = sessions.get(sessionID);
+        if (state === undefined) {
+            state = { turn: [], user: [] };
+            sessions.set(sessionID, state);
+        }
+        return state;
+    }
+    async function lookup(sessionID) {
+        try {
+            const session = await options.getSession(sessionID);
+            if (session === undefined)
+                return { child: true };
+            return { child: session.parentID !== undefined, ...(session.agent === undefined ? {} : { agent: session.agent }) };
+        }
+        catch {
+            // Fail closed: a session whose lineage cannot be read is treated as delegated.
+            return { child: true };
+        }
+    }
+    /** Keeps a command mark only when the plugin sent it; returns true for such a trusted command turn. */
+    function admitCommandMark(event) {
+        const metadata = event.metadata;
+        if (metadata === undefined || !("litopencode" in metadata))
+            return false;
+        const { litopencode: marker, ...rest } = metadata;
+        const accepted = options.acceptCommandMark?.(event.sessionID, marker);
+        if (accepted === undefined) {
+            event.metadata = Object.keys(rest).length === 0 ? undefined : rest;
+            return false;
+        }
+        event.metadata = { ...rest, litopencode: { command: accepted.command, banner: accepted.banner, source: "command" } };
+        options.onActivation?.(event.sessionID, accepted.command);
+        return true;
+    }
+    async function prompt(event) {
+        const input = unwrapRunArgument(event.prompt.text);
+        try {
+            await options.routeModel?.(event.sessionID);
+        }
+        catch { // no-excuse-ok: catch -- a failed route switch must never block the user message.
+            // The session keeps the model the host chose.
+        }
+        if (admitCommandMark(event)) {
+            const state = stateFor(event.sessionID);
+            state.turn = [];
+            state.user = [];
+            return;
+        }
+        const session = await lookup(event.sessionID);
+        if (session.child)
+            return;
+        const state = stateFor(event.sessionID);
+        state.turn = [];
+        state.user = [];
+        if (input.trim() === "")
+            return;
+        if (options.autoHandoffRoute !== undefined) {
+            const reply = await options.autoHandoffRoute(input, "chat");
+            if (reply !== undefined) {
+                state.user.push(autoHandoffSettingText(reply));
+                return;
+            }
+        }
+        try {
+            const knowledge = await queryKnowledge(options.projectRoot, input.slice(0, 4096));
+            if (knowledge.text !== "")
+                state.user.push(knowledge.text);
+        }
+        catch { // no-excuse-ok: catch -- local relevance must never block the user message.
+            // A malformed or unreadable knowledge store stays silent instead of inventing context.
+        }
+        const mode = detectChatActivationMode(input, session.agent);
+        if (mode === undefined)
+            return;
+        const trigger = mode === "lit-handoff" ? "handoff" : mode === "lit-scientific-visualization" ? mode : "lit";
+        let activation = promptForChatActivationMode(mode, input);
+        if (mode === "start-work" && session.agent !== "lit-plan") {
+            const directive = parseStartWorkLifecycleDirective(input, { chat: true });
+            if (directive?.action === "resume") {
+                try {
+                    const receipt = await applyTrustedStartWorkDirective(options.projectRoot, event.sessionID, directive, options.config.boundedAuthority);
+                    state.user.push(receipt.text);
+                    activation = startWorkPromptInjection;
+                }
+                catch {
+                    activation = "BLOCKED: bounded-authority lifecycle resume rejected. Use /start-work with the exact pending boundary, grant, work id, session, and CAS revision.";
+                }
+            }
+        }
+        const reentry = await decideReentry({
+            memory: activationMemory,
+            projectRoot: options.projectRoot,
+            sessionID: event.sessionID,
+            mode,
+            text: input
+        });
+        if (reentry.kind === "continue") {
+            state.turn.push(reentry.text);
+            event.metadata = { ...(event.metadata ?? {}), litopencode: { mode: reentry.mode, trigger, source: "prompt", reentry: "continue" } };
+            options.onActivation?.(event.sessionID, reentry.mode);
+            return;
+        }
+        if (reentry.kind === "resume")
+            activation = `${reentry.line}\n${activation}`;
+        else if (reentry.kind === "confirm")
+            activation = `${activation}\n${reentry.line}`;
+        state.activation = activation;
+        event.metadata = {
+            ...(event.metadata ?? {}),
+            litopencode: { mode, trigger, source: "prompt", ...(reentry.kind === "full" ? {} : { reentry: reentry.kind }) }
+        };
+        options.onActivation?.(event.sessionID, mode);
+        if (reentry.kind !== "confirm" && mode !== "lit-handoff" && mode !== "lit-scientific-visualization") {
+            activationMemory.remember(event.sessionID, mode);
+        }
+        if (mode === "lit-task" || mode === "lit-recap" || mode === "lit-brainstorm" || isReadOnlyWorkflowFamilyPlan(mode))
+            return;
+        try {
+            await operations.init();
+            await operations.append({
+                type: "prompt.activated",
+                trigger,
+                source: "prompt",
+                mode,
+                sessionID: event.sessionID,
+                messageID: event.messageID,
+                ...(session.agent === undefined ? {} : { agent: session.agent }),
+                timestamp: new Date().toISOString()
+            });
+        }
+        catch { // no-excuse-ok: catch -- activation must survive best-effort ledger failure.
+            // The activation text is the primary surface; the ledger write is best-effort.
+        }
+    }
+    async function context(event) {
+        const state = sessions.get(event.sessionID);
+        if (state?.activation !== undefined)
+            event.system.push(text(state.activation));
+        for (const entry of state?.turn ?? [])
+            event.system.push(text(entry));
+        const user = state?.user ?? [];
+        if (user.length > 0 && !appendToLatestUserMessage(event.messages, user)) {
+            for (const entry of user)
+                event.system.push(text(entry));
+        }
+        for (const entry of (await options.extraSystem?.(event.sessionID)) ?? [])
+            event.system.push(text(entry));
+        const rules = { system: [] };
+        await applyStaticRuleInjection({ projectRoot: options.projectRoot, bundledRulesDir, outputStyle: options.config.outputStyle }, { sessionID: event.sessionID }, rules);
+        for (const entry of rules.system)
+            event.system.push(text(entry));
+        const request = options.requestOptions.get(event.agent);
+        if (request !== undefined) {
+            for (const [key, value] of Object.entries(request))
+                if (event.options[key] === undefined)
+                    event.options[key] = value;
+        }
+    }
+    async function compaction(event) {
+        const output = { context: [] };
+        await applyCompactionRuleReset({ sessionID: event.sessionID }, output);
+        for (const entry of output.context)
+            event.system.push(text(entry));
+    }
+    return {
+        prompt,
+        context,
+        compaction,
+        clear(sessionID) {
+            sessions.delete(sessionID);
+            activationMemory.forget(sessionID);
+        }
+    };
+}