@litfamily/litopencode 1.0.31 → 1.0.32

package/dist/activation.js

@@ -7,7 +7,10 @@ import { autoHandoffSettingText } from "./auto-handoff.js";
 import { isReadOnlyWorkflowFamilyPlan } from "./workflow-families.js";
 import { queryKnowledge } from "./knowledge.js";
 import { activationDiscipline } from "./activation-probe.js";
-import { decideReentry } from "./activation-reentry.js";
+import { adhdSessionNote } from "./activation-workflow-prompts.js";
+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";
 // 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.
@@ -15,7 +18,7 @@ export { litHandoffPromptInjection, scientificVisualizationPromptInjection } fro
 export { litActivationBanner } from "./activation-prompt-utils.js";
 export { litLoopPromptInjection, litPlanPromptInjection } from "./activation-primary-prompts.js";
 export { containsStandaloneLitTrigger, detectChatActivationMode } from "./activation-routing.js";
-export { comprehendPromptInjection, debuggingPromptInjection, deepInterviewPromptInjection, gitMasterPromptInjection, litBrainstormPromptInjection, litCruciblePromptInjection, initDeepPromptInjection, litGoalPromptInjection, litRecapPromptInjection, litResearchPromptInjection, lspPromptInjection, lspSetupPromptInjection, litCodePromptInjection, refactorPromptInjection, removeAiSlopsPromptInjection, browserDrivePromptInjection, structuralSearchPromptInjection, rulesPromptInjection, reviewModeForcedNote, reviewWorkPromptInjection, startWorkChatPromptInjection, startWorkPromptInjection, litBurnoffFilePromptInjection, litFetchPromptInjection, litHumanizerPromptInjection } from "./activation-workflow-prompts.js";
+export { comprehendPromptInjection, debuggingPromptInjection, deepInterviewPromptInjection, gitMasterPromptInjection, litBrainstormPromptInjection, litHijackPromptInjection, litAdhdPromptInjection, adhdSessionNote, litCruciblePromptInjection, initDeepPromptInjection, litGoalPromptInjection, litRecapPromptInjection, litResearchPromptInjection, lspPromptInjection, lspSetupPromptInjection, litCodePromptInjection, refactorPromptInjection, removeAiSlopsPromptInjection, browserDrivePromptInjection, structuralSearchPromptInjection, rulesPromptInjection, reviewModeForcedNote, reviewWorkPromptInjection, startWorkChatPromptInjection, startWorkPromptInjection, litBurnoffFilePromptInjection, litFetchPromptInjection, litHumanizerPromptInjection } from "./activation-workflow-prompts.js";
 export function showActivationToast(client, skillId, env = process.env) {
     const label = `🔥 LIT IGNITED · ${activationDiscipline(skillId)} 🔥`;
     const message = supportsMarkGlyphs(env)
@@ -132,13 +135,43 @@ export function createChatMessageActivationHook(projectRoot, options = {}) {
                 // A malformed or unreadable knowledge store stays silent instead of inventing context.
             }
         }
+        if (!childSession && nonEmptyTextParts.length === 1 && output.parts.every((part) => part.type === "text")) {
+            const typed = await typedPromptReply(projectRoot, input.sessionID, nonEmptyTextParts[0].text, options.activationMemory, options.boundedAuthority);
+            if (typed !== undefined) {
+                output.parts.push({
+                    id: `prt_litopencode_typed_${typed.mode.replace("-", "_")}_${idSuffix(input.messageID ?? output.message.id)}`,
+                    sessionID: input.sessionID,
+                    messageID: input.messageID ?? output.message.id,
+                    type: "text",
+                    text: typed.text,
+                    synthetic: true,
+                    metadata: { litopencode: { mode: typed.mode, trigger: "lit", source: "chat.message", typed: typed.kind } }
+                });
+                if (typed.continued)
+                    await options.onSkillContinue?.(input.sessionID, typed.mode, false);
+                return;
+            }
+        }
         if (mode === undefined || childSession)
             return;
         const trigger = mode === "lit-handoff" ? "handoff" : mode === "lit-scientific-visualization" ? mode : "lit";
         const triggerText = nonEmptyTextParts.find((part) => detectChatActivationMode(part.text, agent) === mode)?.text;
         let activationText = promptForChatActivationMode(mode, triggerText);
+        if (mode === "lit-adhd")
+            activationText = `${activationText}\n${adhdSessionNote(input.sessionID)}`;
         if (mode === "start-work" && agent !== "lit-plan" && nonEmptyTextParts.length === 1) {
             const directive = parseStartWorkLifecycleDirective(nonEmptyTextParts[0].text, { chat: true });
+            const planArgument = directive === undefined ? typedStartArgument(nonEmptyTextParts[0].text) : undefined;
+            if (planArgument !== undefined) {
+                const started = await startTypedWork({
+                    projectRoot,
+                    sessionID: input.sessionID,
+                    ...(planArgument === "" ? {} : { plan: planArgument }),
+                    ...(options.boundedAuthority === undefined ? {} : { options: options.boundedAuthority })
+                });
+                if (started.quiet !== true)
+                    activationText = `${started.text}\n${activationText}`;
+            }
             if (directive?.action === "resume") {
                 try {
                     const receipt = await applyTrustedStartWorkDirective(projectRoot, input.sessionID, directive, options.boundedAuthority);
@@ -165,6 +198,15 @@ export function createChatMessageActivationHook(projectRoot, options = {}) {
             activationText = `${reentry.line}\n${activationText}`;
         else if (reentry.kind === "confirm")
             activationText = `${activationText}\n${reentry.line}`;
+        if (options.activationMemory !== undefined &&
+            reentry.kind !== "continue" &&
+            reentry.kind !== "confirm" &&
+            mode !== "lit-handoff" &&
+            mode !== "lit-scientific-visualization") {
+            const recorded = await recordActivation({ memory: options.activationMemory, projectRoot, sessionID: input.sessionID, mode });
+            if (recorded.line !== undefined)
+                activationText = `${activationText}\n${recorded.line}`;
+        }
         output.parts.push({
             id: `prt_litopencode_${markMode.replace("-", "_")}_${idSuffix(input.messageID ?? output.message.id)}`,
             sessionID: input.sessionID,
@@ -186,9 +228,6 @@ export function createChatMessageActivationHook(projectRoot, options = {}) {
             return;
         }
         await options.onSkillActivation?.(input.sessionID, mode, appendedLit);
-        if (reentry.kind !== "confirm" && mode !== "lit-handoff" && mode !== "lit-scientific-visualization") {
-            options.activationMemory?.remember(input.sessionID, mode);
-        }
         if (mode === "lit-scientific-visualization") {
             options.onScientificVisualizationActivation?.(input.sessionID);
         }

package/dist/adhd-next.d.ts

@@ -0,0 +1,51 @@
+import { type ActivationMemory } from "./activation-reentry.ts";
+import type { ChatActivationMode } from "./activation-routing.ts";
+import type { BoundedAuthorityOptions } from "./bounded-authority.ts";
+export declare const adhdNextSchema = "litopencode.adhd-next/v1";
+export declare const adhdNextTtlMs: number;
+export type NextKind = "continue" | "work" | "plan" | "elsewhere";
+export type NextRecord = {
+    readonly schema: typeof adhdNextSchema;
+    readonly kind: NextKind;
+    readonly target: string;
+    readonly at: number;
+    readonly sessionID: string;
+};
+/** True only when the WHOLE prompt is a go word; a go word inside a sentence or a code span is not one. */
+export declare function detectGoWord(text: string): boolean;
+export declare function nextFile(projectRoot: string, sessionID: string): string;
+export declare function writeNext(projectRoot: string, record: Omit<NextRecord, "schema">): Promise<void>;
+/**
+ * Reads and removes the next-step record of THIS session. A record of another session, an older one,
+ * a link, an oversized file or malformed JSON is treated as absent; a file that was read is deleted either way.
+ */
+export declare function consumeNext(projectRoot: string, sessionID: string, now: number): Promise<NextRecord | undefined>;
+export type GoRoute = {
+    readonly text: string;
+    readonly mode: ChatActivationMode;
+    readonly kind: NextKind;
+};
+/**
+ * Turns a live `go` into the existing re-entry or start path. A paused spine returns through the same
+ * resume a `lit continue` takes, running work gets the continue note, and one open plan goes through the typed
+ * start-work path. A pending boundary is never answered here: only `lit approve` or `lit deny` can.
+ */
+export declare function routeGo(input: {
+    readonly projectRoot: string;
+    readonly sessionID: string;
+    readonly text: string;
+    readonly memory?: ActivationMemory;
+    readonly boundedAuthority?: BoundedAuthorityOptions;
+    readonly now?: number;
+}): Promise<GoRoute | undefined>;
+export type TypedPromptReply = {
+    readonly text: string;
+    readonly mode: ChatActivationMode;
+    readonly kind: "approve" | "deny" | NextKind;
+    readonly continued: boolean;
+};
+/**
+ * The whole-prompt typed words of a ROOT user session: `lit approve`, `lit deny` and a live `go`.
+ * Callers pass only prompts that came from the user in a root session; anything else never reaches here.
+ */
+export declare function typedPromptReply(projectRoot: string, sessionID: string, text: string, memory: ActivationMemory | undefined, boundedAuthority: BoundedAuthorityOptions | undefined): Promise<TypedPromptReply | undefined>;

package/dist/adhd-next.js

@@ -0,0 +1,150 @@
+import { constants as fsConstants } from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { createActivationMemory, decideReentry } from "./activation-reentry.js";
+import { startWorkPromptInjection } from "./activation-workflow-prompts.js";
+import { answerBoundary, boundaryVerdict, startTypedWork } from "./start-work-typed.js";
+import { createRuntimePaths } from "./state.js";
+// The brief from lit-adhd ends with one recommended next step and the word `go`. The collector writes that
+// step as a small record for ONE session; a bare `go` only means something while that record is alive.
+// Without it `go`, `고` and `진행` are ordinary words and nothing routes.
+export const adhdNextSchema = "litopencode.adhd-next/v1";
+export const adhdNextTtlMs = 30 * 60_000;
+const safeSessionID = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/u;
+const recordByteLimit = 4096;
+const goWord = /^(?:lit\s+go|go|ㄱㄱ|고|진행)[.!?。]*$/iu;
+/** True only when the WHOLE prompt is a go word; a go word inside a sentence or a code span is not one. */
+export function detectGoWord(text) {
+    return goWord.test(text.trim());
+}
+export function nextFile(projectRoot, sessionID) {
+    if (!safeSessionID.test(sessionID))
+        throw new Error("next-step session id must match [A-Za-z0-9_-]");
+    return path.join(createRuntimePaths(projectRoot).adhdDir, `next-${sessionID}.json`);
+}
+function isNextRecord(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const record = value;
+    return (record.schema === adhdNextSchema &&
+        (record.kind === "continue" || record.kind === "work" || record.kind === "plan" || record.kind === "elsewhere") &&
+        typeof record.target === "string" &&
+        record.target.length <= 512 &&
+        typeof record.at === "number" &&
+        Number.isFinite(record.at) &&
+        typeof record.sessionID === "string");
+}
+export async function writeNext(projectRoot, record) {
+    const file = nextFile(projectRoot, record.sessionID);
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    const existing = await fs.lstat(file).catch(() => undefined);
+    if (existing !== undefined && !existing.isFile())
+        throw new Error("next-step record path is not a regular file");
+    const temp = `${file}.${process.pid}.tmp`;
+    await fs.writeFile(temp, JSON.stringify({ schema: adhdNextSchema, ...record }), { mode: 0o600, flag: "w" });
+    await fs.rename(temp, file);
+}
+/**
+ * Reads and removes the next-step record of THIS session. A record of another session, an older one,
+ * a link, an oversized file or malformed JSON is treated as absent; a file that was read is deleted either way.
+ */
+export async function consumeNext(projectRoot, sessionID, now) {
+    let file;
+    try {
+        file = nextFile(projectRoot, sessionID);
+    }
+    catch {
+        return undefined;
+    }
+    const stat = await fs.lstat(file).catch(() => undefined);
+    if (stat === undefined)
+        return undefined;
+    if (!stat.isFile() || stat.size > recordByteLimit) {
+        if (stat.isFile() || stat.isSymbolicLink())
+            await fs.unlink(file).catch(() => undefined);
+        return undefined;
+    }
+    let parsed;
+    try {
+        const handle = await fs.open(file, fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW);
+        try {
+            parsed = JSON.parse(await handle.readFile("utf8"));
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch {
+        parsed = undefined;
+    }
+    await fs.unlink(file).catch(() => undefined);
+    if (!isNextRecord(parsed) || parsed.sessionID !== sessionID)
+        return undefined;
+    const age = now - parsed.at;
+    return age >= 0 && age <= adhdNextTtlMs ? parsed : undefined;
+}
+/**
+ * Turns a live `go` into the existing re-entry or start path. A paused spine returns through the same
+ * resume a `lit continue` takes, running work gets the continue note, and one open plan goes through the typed
+ * start-work path. A pending boundary is never answered here: only `lit approve` or `lit deny` can.
+ */
+export async function routeGo(input) {
+    if (!detectGoWord(input.text))
+        return undefined;
+    const now = input.now ?? Date.now();
+    const record = await consumeNext(input.projectRoot, input.sessionID, now);
+    if (record === undefined)
+        return undefined;
+    if (record.kind === "continue") {
+        const decision = await decideReentry({
+            memory: input.memory ?? createActivationMemory(),
+            projectRoot: input.projectRoot,
+            sessionID: input.sessionID,
+            mode: "lit-task",
+            text: "lit continue",
+            now
+        });
+        return decision.kind === "continue" ? { text: decision.text, mode: decision.mode, kind: "continue" } : undefined;
+    }
+    if (record.kind === "elsewhere") {
+        // The brief's step belongs to another session or worktree; go here only says where to act.
+        return {
+            text: `LitOpenCode: the user answered go to the lit-adhd brief, but its next step is outside this session: ${record.target} Say in one line where to open it; do not start that work here.`,
+            mode: "lit-adhd",
+            kind: "elsewhere"
+        };
+    }
+    if (record.kind === "work") {
+        return {
+            text: "LitOpenCode: the user answered go to the brief's next step, which is the running start-work run. Keep working from the checked plan; do not restart it, replan or widen what it may touch. A pending boundary still needs `lit approve` from the user.",
+            mode: "start-work",
+            kind: "work"
+        };
+    }
+    const started = await startTypedWork({
+        projectRoot: input.projectRoot,
+        sessionID: input.sessionID,
+        ...(record.target === "" ? {} : { plan: record.target }),
+        ...(input.boundedAuthority === undefined ? {} : { options: input.boundedAuthority })
+    });
+    return { text: `${started.text}\n${startWorkPromptInjection}`, mode: "start-work", kind: "plan" };
+}
+/**
+ * The whole-prompt typed words of a ROOT user session: `lit approve`, `lit deny` and a live `go`.
+ * Callers pass only prompts that came from the user in a root session; anything else never reaches here.
+ */
+export async function typedPromptReply(projectRoot, sessionID, text, memory, boundedAuthority) {
+    const verdict = boundaryVerdict(text);
+    if (verdict !== undefined) {
+        const reply = await answerBoundary({ projectRoot, sessionID, verdict, ...(boundedAuthority === undefined ? {} : { options: boundedAuthority }) });
+        return { text: reply, mode: "start-work", kind: verdict, continued: false };
+    }
+    const go = await routeGo({
+        projectRoot,
+        sessionID,
+        text,
+        ...(memory === undefined ? {} : { memory }),
+        ...(boundedAuthority === undefined ? {} : { boundedAuthority })
+    });
+    return go === undefined ? undefined : { text: go.text, mode: go.mode, kind: go.kind, continued: go.kind !== "plan" && go.kind !== "elsewhere" };
+}

package/dist/cli/managed-skill-assets.d.ts

@@ -1,5 +1,5 @@
 import type { LitOpenCodeRuntimeSkillId } from "../skills.ts";
-export type ManagedSkillId = "lit-brainstorm" | "lit-comprehend" | "lit-handoff" | "lit-scientific-visualization" | "lit-diagram-drawer" | "lit-pptx" | "lit-typographic-motion" | "lit-docx" | "readme-studio" | "frontend-ui-ux" | "visual-qa" | "lit-plan" | "browser-drive" | "lit-humanizer" | "autoresearch" | "autoconference" | "wikify";
+export type ManagedSkillId = "lit-brainstorm" | "lit-hijack" | "lit-adhd" | "lit-comprehend" | "lit-handoff" | "lit-scientific-visualization" | "lit-diagram-drawer" | "lit-schematic" | "lit-pptx" | "lit-typographic-motion" | "lit-docx" | "readme-studio" | "frontend-ui-ux" | "visual-qa" | "lit-plan" | "browser-drive" | "lit-humanizer" | "autoresearch" | "autoconference" | "wikify";
 export type CanonicalManagedAsset = {
     readonly path: string;
     readonly sha256: string;

package/dist/cli/managed-skill-assets.js

@@ -7,10 +7,13 @@ if (managedSkillManifest.schemaVersion !== 1) {
 }
 export function managedSkillDefinition(id) {
     if (id !== "lit-brainstorm" &&
+        id !== "lit-hijack" &&
+        id !== "lit-adhd" &&
         id !== "lit-comprehend" &&
         id !== "lit-handoff" &&
         id !== "lit-scientific-visualization" &&
         id !== "lit-diagram-drawer" &&
+        id !== "lit-schematic" &&
         id !== "lit-pptx" &&
         id !== "lit-typographic-motion" &&
         id !== "lit-docx" &&
@@ -94,6 +97,8 @@ const skillDiscoveryDescriptions = Object.freeze({
     "release-guardrails": "Trigger before any release-shaped action — version bump, tag, publish, changelog, \"is this ready to ship\" — so vocabulary scanning, version lockstep, and a real dry-pack manifest run before the claim is made and publication stays behind explicit user approval.",
     "lit-init": "Trigger when a repository needs agent-facing guidance created or refreshed: \"set up AGENTS.md\", \"document this repo for agents\", onboarding an unfamiliar codebase, or a restructure that left directory guidance stale and misleading.",
     "lit-brainstorm": "Trigger when the question is still open and the user wants options before a decision — \"what could we call it\", \"any ideas for\", \"how else could we do this\", \"brainstorm\", \"ideation\", `lit idea`, `lit brainstorm` — so many different options are generated, clustered, scored against stated criteria, and narrowed to a short list with trade-offs before one hand-off to deep-interview or lit-plan. Do not trigger to plan a chosen thing, to interview toward one spec, or to implement.",
+    "lit-hijack": "Trigger when the user wants the technique in someone else's published work — an X post or article, a repo, a gist, a blog post, a PDF, a transcript — ported into their own skill or system: \"hijack this\", \"port this technique\", `lit hijack`, `lit 하이재킹` — so it is captured with provenance, licence-gated, compared with the target, written as a source-free spec, built apart, and proven on the real surface. Do not trigger to find sources, to brainstorm options, or to copy source text.",
+    "lit-adhd": "Trigger when the user lost the thread or comes back to earlier work — \"where was I\", \"pick up where we left off\", \"what is still open\", several half-finished sessions — via `lit adhd` or `lit rewind`: a read-only brief with one next step that `go` follows.",
     "lit-crucible": "Trigger before planning when the approach itself is uncertain, contested, or expensive to reverse — competing designs, hidden coupling, a request to pressure-test assumptions or find what will go wrong — so independent read-only lanes attack the idea and only surviving evidence-backed insights reach lit-plan.",
     refactor: "Trigger when code should change shape without changing behavior: extracting, renaming, deduplicating, splitting an overgrown module, or paying down structure the user calls messy or hard to follow — so the behavior boundary is pinned by before/after checks and feature work is not smuggled into the diff.",
     "lit-burnoff": "Trigger when text or code reads as machine-written and should not — comments restating the code, hedging filler, decorative headings, invented emphasis — or when the user asks to \"clean this up\", \"make it less AI\", or strip generated padding, while facts, APIs, tests, and accessibility behavior stay intact.",
@@ -114,11 +119,12 @@ const skillDiscoveryDescriptions = Object.freeze({
     "lit-handoff": "Trigger only for explicit `/lit-handoff`, an exact bare `handoff` message, or native selection by the exact `lit-handoff` id.",
     "lit-scientific-visualization": "Trigger only for explicit `/lit-scientific-visualization`, an exact bare `lit-scientific-visualization` message, or native selection by the exact `lit-scientific-visualization` id.",
     "lit-diagram-drawer": "Select this skill from OpenCode's native skill picker when the user needs an architecture map, workflow, schema, decision path, schedule, or conceptual chart. Route product pages and interface layouts to frontend-ui-ux; route measured scientific data and statistical figures to lit-scientific-visualization. Do not claim a slash command or bare-chat route.",
+    "lit-schematic": "Select from OpenCode's native skill picker when the reader must see real hardware: a P&ID, PFD or equipment layout, a journal apparatus figure, or an isometric cutaway of a vessel or exchanger; a bounded lit drawing request directs the model to load it. Route abstract boxes-and-arrows to lit-diagram-drawer and measured-data plots to lit-scientific-visualization. Do not claim a slash command or bare-id chat route.",
     "lit-pptx": "Select for a PowerPoint deck or presentation, including a bounded lit request for slides. Keep editable Markdown and PPTX together, run the QA gate, and inspect the render.",
     "lit-typographic-motion": "Select for a new film or video. Write the treatment first, then render on the stage path (a captured page) or the type path (words alone), gate it and look at the frames; a README cover loop takes cover mode. Editing existing footage or embedding a video in a page is outside this route.",
     "lit-docx": "Select for a Word report, proposal, or document, including a bounded lit report request. Keep editable Markdown and DOCX together; select publisher profiles when specified and inspect rendered pages.",
     "readme-studio": "Select by native skill name for factual README writing and local cover composition. Inspect actual session image capability; never infer generation support or authorize publication from selection.",
-    "frontend-ui-ux": "Trigger the moment interface work is described, not after it starts — \"design a settings page\", \"redesign the dashboard\", \"build a login screen\", or any making verb aimed at a UI, screen, layout, component, or stylesheet — so compact direction and existing tokens shape the authorized build. Evolve the contract with implementation and inspect renders; review and plan intent remains read-only. Also on the exact `frontend-ui-ux` id. The SKILL.md reference router names which of the sixteen shipped reference documents answers which question.",
+    "frontend-ui-ux": "Trigger the moment interface work is described, not after it starts — \"design a settings page\", \"redesign the dashboard\", \"build a login screen\", or any making verb aimed at a UI, screen, layout, component, or stylesheet — so compact direction and existing tokens shape the authorized build. Evolve the contract with implementation and inspect renders; review and plan intent remains read-only. Also on the exact `frontend-ui-ux` id. The SKILL.md reference router names which shipped reference document answers which question. A new page or screen locks one house style, layout family and signature moment first (references/house-styles.md); the look is rich unless the request asks for minimal or calm.",
     "visual-qa": "Trigger when a rendered surface needs to be checked rather than described — an explicit `visual-qa` request, or verifying that an interface change actually looks and behaves right. Selection does not make a browser callable: the shipped capture playbook names the exact blocked code per unavailable channel, and a blocked check reported honestly outranks an unproven pass.",
     autoresearch: "Trigger when a measurable objective needs repeated hypothesis, experiment, evaluation, and keep/revert decisions, or when its debug, fix, learn, plan, predict, reason, scenario, security, or readiness modes fit the request.",
     autoconference: "Trigger when several genuinely independent research lanes should explore partitions and exchange peer-reviewed packets; block rather than role-play when the current root lacks real OpenCode task capability.",

package/dist/cli/native-skill-integrity.js

@@ -112,7 +112,7 @@ export async function nativeSkillContent(metadata, skill) {
         ...description.split("\n").map((line) => "  " + line),
         "metadata:",
         `  ${litOpenCodeGeneratedFrontmatterMarker.replace(": true", ': "true"')}`,
-        ...(skill.id === "lit-diagram-drawer" ? ["  reader_projection: shared_rule"] : []),
+        ...(skill.id === "lit-diagram-drawer" || skill.id === "lit-schematic" ? ["  reader_projection: shared_rule"] : []),
         "---",
         "",
         body.trimEnd(),

package/dist/cli.js

@@ -81,11 +81,17 @@ function helpText() {
         "",
         "Native offline skills:",
         "  frontend-ui-ux provides deterministic design-contract retrieval from a packaged MIT corpus,",
-        "                 plus sixteen shipped reference documents routed from its SKILL.md.",
+        "                 plus a locked house-style kit and its shipped reference documents routed from its SKILL.md.",
         "  visual-qa validates evidence, PNGs, terminal layouts, and independent review receipts,",
         "            ships a per-channel capture playbook, and keeps blocked codes separate from fail codes.",
         "  lit-diagram-drawer creates conceptual, editorial, and technical diagrams with packaged type guides,",
         "                     local verifiers, bounded importers, and exports that never install tools.",
+        "  lit-schematic draws P&IDs, PFDs, journal apparatus figures and isometric cutaways of real equipment",
+        "                with a symbol library, a QA gate, exports and a mandatory look at the render.",
+        "  lit-hijack ports the mechanism of someone else's published work into your skill or system with a",
+        "             phase-gate script (hijack.mjs), a licence table, a source-overlap check and a parity proof.",
+        "  lit-adhd (alias lit-rewind) briefs earlier sessions in this worktree family with real progress only,",
+        "           a roadmap and one recommended step you follow with go; lit approve and lit deny answer a boundary.",
         "  lit-typographic-motion directs films from a treatment: a captured stage page or the type engine,",
         "                         and seamless README cover loops gated on the decoded WebP.",
         "  Typographic-motion engine adapted from mexicat/pdoom-video (MIT, Giacomo Magnanini), commit `ca251e3`.",

package/dist/commands.d.ts

@@ -1,7 +1,7 @@
 import type { Hooks } from "@opencode-ai/plugin";
 import type { BoundedAuthorityOptions } from "./bounded-authority.ts";
 import { type AutoHandoffRouteMode } from "./auto-handoff.ts";
-export type LitOpenCodeCommandId = "lit" | "lit-loop" | "litwork" | "lit-work" | "start-work" | "review-work" | "lit-plan" | "litgoal" | "lit-goal" | "litresearch" | "lit-research" | "lit-init" | "lit-crucible" | "lit-brainstorm" | "lit-burnoff-file" | "lit-fetch" | "refactor" | "lit-burnoff" | "lit-code" | "debugging" | "lit-commit" | "lsp" | "lsp-setup" | "rules" | "deep-interview" | "structural-search" | "browser-drive" | "lit-recap" | "lit-comprehend" | "lit-handoff" | "lit-scientific-visualization" | "lit-humanizer" | "autoresearch" | "autoresearch-debug" | "autoresearch-fix" | "autoresearch-learn" | "autoresearch-plan" | "autoresearch-predict" | "autoresearch-reason" | "autoresearch-scenario" | "autoresearch-security" | "autoresearch-ship" | "autoconference" | "autoconference-analyze" | "autoconference-debate" | "autoconference-plan" | "autoconference-resume" | "autoconference-ship" | "autoconference-survey" | "wikify-init" | "wikify-ingest" | "wikify-query" | "wikify-save" | "wikify-lint";
+export type LitOpenCodeCommandId = "lit" | "lit-loop" | "litwork" | "lit-work" | "start-work" | "review-work" | "lit-plan" | "litgoal" | "lit-goal" | "litresearch" | "lit-research" | "lit-init" | "lit-crucible" | "lit-brainstorm" | "lit-hijack" | "lit-adhd" | "lit-rewind" | "lit-burnoff-file" | "lit-fetch" | "refactor" | "lit-burnoff" | "lit-code" | "debugging" | "lit-commit" | "lsp" | "lsp-setup" | "rules" | "deep-interview" | "structural-search" | "browser-drive" | "lit-recap" | "lit-comprehend" | "lit-handoff" | "lit-scientific-visualization" | "lit-humanizer" | "autoresearch" | "autoresearch-debug" | "autoresearch-fix" | "autoresearch-learn" | "autoresearch-plan" | "autoresearch-predict" | "autoresearch-reason" | "autoresearch-scenario" | "autoresearch-security" | "autoresearch-ship" | "autoconference" | "autoconference-analyze" | "autoconference-debate" | "autoconference-plan" | "autoconference-resume" | "autoconference-ship" | "autoconference-survey" | "wikify-init" | "wikify-ingest" | "wikify-query" | "wikify-save" | "wikify-lint";
 export type LitOpenCodeCommand = {
     readonly id: LitOpenCodeCommandId;
     readonly slash: string;
@@ -175,6 +175,33 @@ export declare const litOpenCodeCommands: readonly ({
     activationText: string;
     agent?: undefined;
     readOnly?: undefined;
+} | {
+    id: "lit-hijack";
+    slash: string;
+    title: string;
+    description: string;
+    banner: string;
+    activationText: string;
+    agent?: undefined;
+    readOnly?: undefined;
+} | {
+    id: "lit-adhd";
+    slash: string;
+    title: string;
+    description: string;
+    banner: string;
+    activationText: string;
+    agent?: undefined;
+    readOnly?: undefined;
+} | {
+    id: "lit-rewind";
+    slash: string;
+    title: string;
+    description: string;
+    banner: string;
+    activationText: string;
+    agent?: undefined;
+    readOnly?: undefined;
 } | {
     id: "refactor";
     slash: string;

package/dist/commands.js

@@ -1,9 +1,10 @@
 import { activationBanner } from "./activation-probe.js";
 import { renamedSkillId, skillRenameNote } from "./skill-renames.js";
-import { comprehendPromptInjection, debuggingPromptInjection, deepInterviewPromptInjection, gitMasterPromptInjection, lspPromptInjection, lspSetupPromptInjection, rulesPromptInjection, browserDrivePromptInjection, structuralSearchPromptInjection, litGoalPromptInjection, litBrainstormPromptInjection, litCruciblePromptInjection, initDeepPromptInjection, litLoopPromptInjection, litPlanPromptInjection, litRecapPromptInjection, litHandoffPromptInjection, litResearchPromptInjection, litCodePromptInjection, refactorPromptInjection, removeAiSlopsPromptInjection, reviewModeForcedNote, reviewWorkPromptInjection, scientificVisualizationPromptInjection, startWorkPromptInjection, litBurnoffFilePromptInjection, litFetchPromptInjection, litHumanizerPromptInjection } from "./activation.js";
+import { comprehendPromptInjection, debuggingPromptInjection, deepInterviewPromptInjection, gitMasterPromptInjection, lspPromptInjection, lspSetupPromptInjection, rulesPromptInjection, browserDrivePromptInjection, structuralSearchPromptInjection, litGoalPromptInjection, litBrainstormPromptInjection, litHijackPromptInjection, litAdhdPromptInjection, adhdSessionNote, litCruciblePromptInjection, initDeepPromptInjection, litLoopPromptInjection, litPlanPromptInjection, litRecapPromptInjection, litHandoffPromptInjection, litResearchPromptInjection, litCodePromptInjection, refactorPromptInjection, removeAiSlopsPromptInjection, reviewModeForcedNote, reviewWorkPromptInjection, scientificVisualizationPromptInjection, startWorkPromptInjection, litBurnoffFilePromptInjection, litFetchPromptInjection, litHumanizerPromptInjection } from "./activation.js";
 import { createLitGoalOperations } from "./ledger.js";
 import { commandAliasOwnership } from "./cli/command-alias-ownership.js";
 import { applyTrustedStartWorkDirective, parseStartWorkLifecycleDirective } from "./bounded-authority-hooks.js";
+import { startTypedWork, typedStartArgument } from "./start-work-typed.js";
 import { autoHandoffSettingText } from "./auto-handoff.js";
 import { formatResolvedPlanNotice, formatSavedPlanNotice, parsePlanSaveArgument, persistApprovedPlan, resolveLatestDurablePlan } from "./durable-plan.js";
 import { isWorkflowFamilyMode, workflowFamilyCommandDefinitions } from "./workflow-families.js";
@@ -143,6 +144,30 @@ export const litOpenCodeCommands = Object.freeze([
         banner: activationBanner("lit-brainstorm"),
         activationText: litBrainstormPromptInjection
     },
+    {
+        id: "lit-hijack",
+        slash: "/lit-hijack",
+        title: "LitOpenCode Lit Hijack",
+        description: "Port the mechanism in someone else's published work into your own skill or system: capture with provenance, licence gate, gap, source-free spec, separate build, parity proof and report.",
+        banner: activationBanner("lit-hijack"),
+        activationText: litHijackPromptInjection
+    },
+    {
+        id: "lit-adhd",
+        slash: "/lit-adhd",
+        title: "LitOpenCode Lit Adhd",
+        description: "Pick up where you left off: a read-only brief of earlier sessions in this worktree family with status, real progress, a roadmap and one recommended next step you follow with go.",
+        banner: activationBanner("lit-adhd"),
+        activationText: litAdhdPromptInjection
+    },
+    {
+        id: "lit-rewind",
+        slash: "/lit-rewind",
+        title: "LitOpenCode Lit Rewind",
+        description: "Alias for /lit-adhd.",
+        banner: activationBanner("lit-rewind"),
+        activationText: litAdhdPromptInjection
+    },
     {
         id: "refactor",
         slash: "/refactor",
@@ -311,6 +336,10 @@ function commandMode(command) {
         return "lit-crucible";
     if (command.id === "lit-brainstorm")
         return "lit-brainstorm";
+    if (command.id === "lit-hijack")
+        return "lit-hijack";
+    if (command.id === "lit-adhd" || command.id === "lit-rewind")
+        return "lit-adhd";
     if (command.id === "litgoal" || command.id === "lit-goal")
         return "litgoal";
     if (command.id === "refactor")
@@ -470,6 +499,7 @@ export function createCommandActivationHook(projectRoot, options = {}) {
                 return;
             }
         }
+        let typedStartNote;
         if (command.id === "start-work") {
             if (/^save-plan(?:\s|$)/u.test(input.arguments.trim())) {
                 const request = parsePlanSaveArgument(input.arguments);
@@ -552,6 +582,19 @@ export function createCommandActivationHook(projectRoot, options = {}) {
                 });
                 return;
             }
+            if (directive === undefined && !lifecycleIntent) {
+                const planArgument = typedStartArgument(`start-work ${input.arguments}`.trim());
+                if (planArgument !== undefined) {
+                    const started = await startTypedWork({
+                        projectRoot,
+                        sessionID: input.sessionID,
+                        ...(planArgument === "" ? {} : { plan: planArgument }),
+                        ...(options.boundedAuthority === undefined ? {} : { options: options.boundedAuthority })
+                    });
+                    if (started.quiet !== true)
+                        typedStartNote = started.text;
+                }
+            }
             if (directive !== undefined) {
                 let lifecycleText;
                 try {
@@ -595,6 +638,10 @@ export function createCommandActivationHook(projectRoot, options = {}) {
                 activationText = `${command.activationText}\n\n${formatResolvedPlanNotice(durablePlan)}`;
             }
         }
+        if (command.id === "lit-adhd" || command.id === "lit-rewind")
+            activationText = `${activationText}\n${adhdSessionNote(input.sessionID)}`;
+        if (typedStartNote !== undefined)
+            activationText = `${typedStartNote}\n${activationText}`;
         output.parts.push({
             id: `prt_litopencode_${command.id.replace(/-/g, "_")}_activation`,
             sessionID: input.sessionID,

package/dist/features.d.ts

@@ -1,5 +1,5 @@
 export type LitOpenCodeBindingKind = "agent" | "cli" | "command" | "config" | "hook" | "tool";
-export type LitOpenCodeFeatureId = "planning-start-work-loop" | "lit-litwork-activation" | "start-work" | "review-work" | "litresearch" | "durable-ledger" | "bounded-authority-lifecycle" | "agent-roster" | "lit-plan" | "reference-benchmark-claims" | "native-goal-verdict" | "doctor-install" | "search-workflow-ideas" | "lit-fetch" | "guardrails" | "lit-init" | "lit-crucible" | "lit-brainstorm" | "refactor" | "lit-burnoff" | "lit-burnoff-file" | "comment-checker" | "lit-code" | "debugging" | "lit-commit" | "lsp" | "lsp-setup" | "rules" | "deep-interview" | "structural-search" | "browser-drive" | "lit-humanizer" | "lit-recap" | "lit-comprehend" | "lit-handoff" | "lit-scientific-visualization" | "lit-diagram-drawer" | "lit-pptx" | "lit-typographic-motion" | "lit-docx" | "readme-studio" | "frontend-ui-ux" | "visual-qa" | "autoresearch" | "autoconference" | "wikify";
+export type LitOpenCodeFeatureId = "planning-start-work-loop" | "lit-litwork-activation" | "start-work" | "review-work" | "litresearch" | "durable-ledger" | "bounded-authority-lifecycle" | "agent-roster" | "lit-plan" | "reference-benchmark-claims" | "native-goal-verdict" | "doctor-install" | "search-workflow-ideas" | "lit-fetch" | "guardrails" | "lit-init" | "lit-crucible" | "lit-brainstorm" | "lit-hijack" | "lit-adhd" | "workflow-stack" | "refactor" | "lit-burnoff" | "lit-burnoff-file" | "comment-checker" | "lit-code" | "debugging" | "lit-commit" | "lsp" | "lsp-setup" | "rules" | "deep-interview" | "structural-search" | "browser-drive" | "lit-humanizer" | "lit-recap" | "lit-comprehend" | "lit-handoff" | "lit-scientific-visualization" | "lit-diagram-drawer" | "lit-schematic" | "lit-pptx" | "lit-typographic-motion" | "lit-docx" | "readme-studio" | "frontend-ui-ux" | "visual-qa" | "autoresearch" | "autoconference" | "wikify";
 export type LitOpenCodeFeatureBinding = {
     readonly kind: LitOpenCodeBindingKind;
     readonly id: string;
@@ -441,6 +441,64 @@ export declare const litOpenCodeFeatures: readonly ({
         description: string;
     })[];
     verification: string[];
+} | {
+    id: "lit-hijack";
+    title: string;
+    summary: string;
+    bindings: ({
+        kind: "config";
+        id: string;
+        surface: string;
+        description: string;
+    } | {
+        kind: "command";
+        id: string;
+        surface: string;
+        description: string;
+    } | {
+        kind: "agent";
+        id: string;
+        surface: string;
+        description: string;
+    })[];
+    verification: string[];
+} | {
+    id: "lit-adhd";
+    title: string;
+    summary: string;
+    bindings: ({
+        kind: "config";
+        id: string;
+        surface: string;
+        description: string;
+    } | {
+        kind: "command";
+        id: string;
+        surface: string;
+        description: string;
+    } | {
+        kind: "hook";
+        id: string;
+        surface: string;
+        description: string;
+    })[];
+    verification: string[];
+} | {
+    id: "workflow-stack";
+    title: string;
+    summary: string;
+    bindings: ({
+        kind: "config";
+        id: string;
+        surface: string;
+        description: string;
+    } | {
+        kind: "hook";
+        id: string;
+        surface: string;
+        description: string;
+    })[];
+    verification: string[];
 } | {
     id: "refactor";
     title: string;
@@ -845,6 +903,27 @@ export declare const litOpenCodeFeatures: readonly ({
         description: string;
     })[];
     verification: string[];
+} | {
+    id: "lit-schematic";
+    title: string;
+    summary: string;
+    bindings: ({
+        kind: "config";
+        id: string;
+        surface: string;
+        description: string;
+    } | {
+        kind: "hook";
+        id: string;
+        surface: string;
+        description: string;
+    } | {
+        kind: "cli";
+        id: string;
+        surface: string;
+        description: string;
+    })[];
+    verification: string[];
 } | {
     id: "lit-typographic-motion";
     title: string;