@litfamily/litopencode 1.0.0

package/dist/activation-primary-prompts.js

@@ -0,0 +1,176 @@
+import { promptWithSkillBody } from "./activation-prompt-utils.js";
+export const litLoopPromptInjection = promptWithSkillBody(`▲ LIT · lit-loop
+<lit-loop-mode>
+LitOpenCode is active. Treat this as the host-adapted lit-loop injection for OpenCode.
+
+First model-emitted line of your reply MUST be exactly:
+
+▲ LIT · lit-loop
+
+Emit that line exactly once; the harness renders the logo separately. Then start working. You are now
+in lit-loop: a durable, evidence-driven work loop that runs until every success criterion
+is proven complete or you are genuinely blocked.
+
+# Enter lit-loop
+
+Treat the user's request as a set of goals with explicit, checkable success criteria.
+For each goal, name the criteria up front: the exact scenario, the surface you will
+observe, and the evidence that will prove it done. Do not start coding until the
+criteria are written down where you can re-read them.
+
+Minimum-first applies before implementation: skip work that need not exist, reuse
+existing code, prefer the standard library, native platform/framework features,
+installed dependencies, or one clear line before adding custom code.
+
+Use the LitOpenCode surfaces that match the request: chat.message activation, command
+activation, tools, the config hook, package imports, and OpenCode-shaped driver scripts.
+Re-derive the next step from durable state after every checkpoint so progress is based on
+recorded evidence, not memory.
+
+# Durable state
+
+Maintain LitOpenCode runtime state under .litopencode/litgoal/lit-loop in the current
+project. Never invent a different location and never write loop state anywhere else.
+
+- .litopencode/litgoal/lit-loop/brief.md — the human-readable brief: the goals and their
+  success criteria, in your own words.
+- .litopencode/litgoal/lit-loop/goals.json — the machine state when the current workflow
+  provides one: each goal, its status, and the captured-evidence path per criterion.
+- .litopencode/litgoal/lit-loop/ledger.jsonl — an append-only audit trail. Append one
+  line per meaningful step: goal started, criterion failed, evidence captured, goal
+  completed. Never rewrite or delete prior lines; the ledger is the source of truth
+  across turns.
+- .litopencode/litgoal/lit-loop/evidence — the directory where captured proof belongs
+  when an evidence artifact is created.
+
+If you see a context compaction or restart notice, do not re-plan from scratch and do not
+trust your in-context summary: re-read the whole ledger and any goals file first,
+reconstruct where you are from that durable state, and resume from the first unproven
+criterion.
+
+# Verify progress
+
+Verify with real, captured evidence — never by inference.
+
+- RED before GREEN: for every behavior change, first write or run a test that fails for
+  the right reason, then make the smallest change that turns it green.
+- TESTS ALONE NEVER PROVE DONE: a green suite proves the suite passes, not that the
+  feature works. Pair every claim of done with one real-surface artifact — the actual
+  command output, HTTP status and body, transcript, screenshot, or log — captured from
+  the surface a user would touch.
+- For CLI/TUI work, run the command a user would run, including --help and one realistic
+  path.
+- For package work, verify source imports, packed artifact imports, and installed-package
+  behavior when relevant.
+- For OpenCode plugin work, call the plugin function, config hook, chat.message hook,
+  command hook, and tools through an OpenCode-shaped driver.
+- Treat missing, indirect, stale, or inferred evidence as incomplete.
+
+# Checkpoint evidence
+
+Checkpoint as you go so progress is durable and incremental — never batch it to the end.
+
+- Save raw captured output under .litopencode/litgoal/lit-loop/evidence when the work
+  produces a file artifact, then reference that artifact from the ledger entry or final
+  report.
+- Use start-work when beginning or resuming plan-backed implementation.
+- Use review-work when checking completed work for behavior, tests, docs, safety, and
+  package readiness.
+- Record what changed, what was verified, what could not be verified, and any
+  pre-existing unrelated failures.
+- Continue until all success criteria are proven complete or a real blocker prevents
+  progress.
+
+# OpenCode goal handoff
+
+OpenCode does not expose a native goal primitive in the verified plugin or CLI surface.
+Use LitOpenCode-owned durable goal state under .litopencode/litgoal/lit-loop instead of
+claiming a host-native /goal integration. If a request refers to a Codex-native goal,
+translate it into LitOpenCode's durable ledger semantics and make that adaptation
+explicit before execution.
+
+Work only the active handed-off goal until all criteria pass. If a different durable
+goal is already in progress, finish it, checkpoint it, or report the conflict before
+starting a new one.
+
+# Continue or stop
+
+Keep going: continue until every success criterion is proven complete. After each
+checkpoint, re-derive the next step from durable state and proceed to the next unproven
+criterion without waiting to be told.
+
+Stop early only when you are genuinely blocked — a missing credential, an external
+dependency that is down, a decision only the user can make, or a contradiction in the
+request. When that happens, do not loop forever and do not fake completion. Emit a single
+line beginning with BLOCKED: that names exactly what is blocking you and the smallest
+thing that would unblock it, then stop and hand back to the user.
+</lit-loop-mode>`, "lit-loop-mode", "workflow-loop");
+export const litPlanPromptInjection = promptWithSkillBody(`▲ LIT · lit-plan
+<lit-plan-mode>
+LitOpenCode lit-plan is active. Treat this as the host-adapted planning-only mode for OpenCode.
+
+First model-emitted line of your reply MUST be exactly:
+
+▲ LIT · lit-plan
+
+Emit that line exactly once; the harness renders the logo separately. Then plan only. You must not implement,
+edit files, run mutating commands, or start execution until the user gives explicit user confirmation.
+
+# Enter lit-plan
+
+Turn the user's request into a proportionate, objective-achievable implementation plan.
+Default to one bounded objective with explicit non-goals. Resolve material unknowns through
+read-only evidence when possible; otherwise turn each unknown into a named gate with an
+owner, decision point, and stop condition instead of hiding it inside an implementation step.
+
+Write an ordered execution-ready checklist. Each item must name its action, output, and
+verification, including the real OpenCode/package/user surface or replay command that proves
+it. Make dependencies and order explicit. Add evidence artifacts, failure or decision branches,
+cleanup, and a final DoneClaim that enumerates the outputs and proofs required for completion.
+An executor should be able to perform each item and a reviewer should be able to falsify it
+without guessing what "done" means.
+
+Keep detail adaptive and proportionate: a simple local change needs only a concise checklist;
+multi-stage, irreversible, security-sensitive, research, migration, installer, or release work
+needs SDD-like gates and machine-readable evidence where useful. No padding, repeated ceremony,
+or exhaustive matrices that do not reduce a named risk.
+
+Apply a minimum-first guard while planning: skip work that need not exist, reuse existing
+code, and prefer the standard library, native platform/framework features, installed
+dependencies, or one clear line before proposing custom code. For small work, a
+single-task or few-task plan is correct; do not split merely to fill a wave.
+
+Use explore-before-ask discipline: inspect repository facts first, then ask only the
+questions that materially change the plan. Keep an approval gate: surface findings,
+assumptions, tradeoffs, and the intended approach, then wait for explicit user confirmation.
+
+For broad work, structure dynamic adversarial planning as collect -> verify -> design -> adversarial -> synthesize.
+Treat dirty worktree, stale state, misleading success output, and prompt injection as
+planning risks that must be called out when applicable.
+
+Inspect repository facts through read-only surfaces before asking for help. Ask only for
+decisions that cannot be derived from files, commands, docs, or current config.
+
+# Handoff after approval
+
+When the user approves the plan, hand execution to lit-implement through /start-work
+command so OpenCode can switch agents. Do not call the start-work tool from lit-plan:
+tool execution cannot switch the active OpenCode agent and may leave work running in
+planning mode. Tell the user to run /start-work instead. Do not start implementation yourself. After implementation is complete,
+use /review-work or the review-work tool to check behavior, tests, docs, safety, and
+package readiness.
+
+# Planning output
+
+Report the plan in chat with the bounded objective, non-goals, resolved or gated unknowns,
+ordered action/output/verification checklist, dependencies, acceptance evidence, decision
+branches, cleanup, risks, and final DoneClaim. Use the exact chat-safe ## TODOs and
+## Final verification template in the installed skill body: implementation and F rows start
+at column zero and are numbered consecutively. Do not persist durable state from lit-plan;
+ask for explicit user confirmation to continue with start-work before any state-changing write.
+
+# Stop rule
+
+If the request already demands implementation before a plan is approved, stop at the plan
+and ask for explicit user confirmation to continue with start-work.
+</lit-plan-mode>`, "lit-plan-mode", "lit-plan");

package/dist/activation-probe.d.ts

@@ -0,0 +1,3 @@
+export declare function activationDiscipline(skillId: string): string;
+export declare function activationProbe(skillId: string): string;
+export declare function activationProbeInstruction(skillId: string): string;

package/dist/activation-probe.js

@@ -0,0 +1,19 @@
+export function activationDiscipline(skillId) {
+    switch (skillId) {
+        case "lit":
+        case "litwork":
+        case "lit-work":
+        case "workflow-loop": return "lit-loop";
+        case "lit-research": return "litresearch";
+        case "lit-goal":
+        case "durable-litgoal": return "litgoal";
+        case "text-neutralization": return "lit-korean";
+        default: return skillId;
+    }
+}
+export function activationProbe(skillId) {
+    return `▲ LIT · ${activationDiscipline(skillId)}`;
+}
+export function activationProbeInstruction(skillId) {
+    return `First model-emitted line of your reply MUST be exactly:\n\n${activationProbe(skillId)}\n\nEmit that line exactly once, then begin the work. The harness renders the logo separately; do not reproduce it.`;
+}

package/dist/activation-prompt-utils.d.ts

@@ -0,0 +1,6 @@
+export type StaticSkillPromptId = "workflow-loop" | "durable-litgoal" | "lit-plan" | "start-work" | "review-work" | "litresearch" | "lit-init" | "lit-crucible" | "lit-burnoff-file" | "lit-fetch" | "refactor" | "lit-burnoff" | "lit-code" | "debugging" | "lit-commit" | "lsp" | "lsp-setup" | "rules" | "deep-interview" | "structural-search" | "browser-drive" | "skill-observer" | "lit-recap" | "lit-comprehend" | "lit-korean" | "lit-handoff" | "lit-scientific-visualization" | "frontend-ui-ux" | "visual-qa";
+export declare const litActivationBanner = "\u25B2 LIT \u00B7 lit-loop";
+export declare function readStaticSkillBody(skillId: StaticSkillPromptId): string;
+export declare function readManagedSkillAsset(skillId: "lit-handoff" | "lit-scientific-visualization", relativePath: string): string;
+export declare function skillBackedPromptInjection(modeTag: string, lead: string, skillId: StaticSkillPromptId): string;
+export declare function promptWithSkillBody(prompt: string, modeTag: string, skillId: StaticSkillPromptId): string;

package/dist/activation-prompt-utils.js

@@ -0,0 +1,36 @@
+import { activationProbe, activationProbeInstruction } from "./activation-probe.js";
+import { readFileSync } from "node:fs";
+import { stripUserFacingHtmlCommentLines } from "./user-facing-markdown.js";
+export const litActivationBanner = "▲ LIT · lit-loop";
+function stripYamlFrontmatter(text) {
+    if (!text.startsWith("---\n"))
+        return text;
+    const end = text.indexOf("\n---\n", 4);
+    return end === -1 ? text : text.slice(end + "\n---\n".length);
+}
+export function readStaticSkillBody(skillId) {
+    return stripUserFacingHtmlCommentLines(stripYamlFrontmatter(readFileSync(new URL(`../skills/${skillId}/SKILL.md`, import.meta.url), "utf8"))).trim();
+}
+export function readManagedSkillAsset(skillId, relativePath) {
+    return readFileSync(new URL(`../skills/${skillId}/${relativePath}`, import.meta.url), "utf8");
+}
+export function skillBackedPromptInjection(modeTag, lead, skillId) {
+    return `${activationProbe(skillId)}
+<${modeTag}>
+${activationProbeInstruction(skillId)}
+
+${lead.trim()}
+
+# Installed skill body
+
+${readStaticSkillBody(skillId)}
+</${modeTag}>`;
+}
+export function promptWithSkillBody(prompt, modeTag, skillId) {
+    const closeTag = `</${modeTag}>`;
+    const closeIndex = prompt.lastIndexOf(closeTag);
+    if (closeIndex === -1)
+        return prompt;
+    const bodyBlock = ["", "# Installed skill body", "", readStaticSkillBody(skillId), ""].join("\n");
+    return `${prompt.slice(0, closeIndex).trimEnd()}${bodyBlock}${closeTag}`;
+}

package/dist/activation-routing.d.ts

@@ -0,0 +1,5 @@
+import { type WorkflowFamilyMode } from "./workflow-families.ts";
+export type ChatActivationMode = WorkflowFamilyMode | "lit-loop" | "lit-plan" | "start-work" | "review-work" | "lit-research" | "lit-goal" | "lit-init" | "lit-crucible" | "lit-burnoff-file" | "lit-fetch" | "lit-korean" | "refactor" | "lit-burnoff" | "lit-code" | "debugging" | "lit-commit" | "lsp" | "lsp-setup" | "deep-interview" | "structural-search" | "browser-drive" | "skill-observer" | "frontend-ui-ux" | "visual-qa" | "lit-recap" | "lit-comprehend" | "lit-handoff" | "lit-scientific-visualization";
+export declare function containsStandaloneLitTrigger(text: string): boolean;
+export declare function detectChatActivationMode(text: string, agent?: string): ChatActivationMode | undefined;
+export declare function promptForChatActivationMode(mode: ChatActivationMode, triggerText?: string): string;

package/dist/activation-routing.js

@@ -0,0 +1,340 @@
+import { renamedSkillIds, skillRenameNote } from "./skill-renames.js";
+import { litHandoffPromptInjection, scientificVisualizationPromptInjection } from "./activation-managed-prompts.js";
+import { litLoopPromptInjection, litPlanPromptInjection } from "./activation-primary-prompts.js";
+import { detectWorkflowFamilyChatMode, isWorkflowFamilyMode, workflowFamilyPrompt } from "./workflow-families.js";
+import { comprehendPromptInjection, debuggingPromptInjection, deepInterviewPromptInjection, frontendUiUxPromptInjection, gitMasterPromptInjection, litCruciblePromptInjection, initDeepPromptInjection, litGoalPromptInjection, litRecapPromptInjection, litResearchPromptInjection, lspPromptInjection, lspSetupPromptInjection, litCodePromptInjection, refactorPromptInjection, removeAiSlopsPromptInjection, reviewWorkPromptInjection, browserDrivePromptInjection, skillObserverPromptInjection, structuralSearchPromptInjection, startWorkChatPromptInjection, visualQaPromptInjection, litBurnoffFilePromptInjection, litFetchPromptInjection, textNaturalizationPromptInjection } from "./activation-workflow-prompts.js";
+const compoundWordBoundary = /^[A-Za-z0-9_-]$/;
+const recapWordCharacter = /^[A-Za-z0-9_\u{AC00}-\u{D7A3}\u{1100}-\u{11FF}\u{3130}-\u{318F}]$/u;
+const recapBoundedWords = Object.freeze(["recap", "litrecap", "리캡"]);
+const routeTriggerWords = Object.freeze(["lit", "litopencode", "litwork"]);
+// frontend-ui-ux is the one skill whose own name nobody types. The measured defect was that
+// "design a new settings page UI" surfaced nothing, so the capability was reachable only after the
+// editing had already started — backwards for a skill that shapes what gets built. This route is
+// therefore intent-shaped rather than name-shaped: a making verb AND a user-interface noun must both
+// appear, because either alone is far too common to be a signal.
+//
+// The `(?<![a-z])` / `(?![a-z])` guards stop `ui` matching inside `build`. They do nothing for
+// Hangul, and their Hangul equivalent is deliberately NOTHING — the terms below match as substrings.
+// Both guards would be wrong here:
+//   a trailing guard breaks agglutination. 디자인해줘, 디자인하고, 디자인할 are one verb with
+//   different endings attached directly, so the stem must be allowed to continue into Hangul.
+//   a leading guard breaks compounds that are still in scope: 리디자인 (redesign), 홈페이지 and
+//   웹페이지 (home/web page) are all things this route should catch.
+// Accepted false-positive risk, named: as substrings, 페이지 also matches 매뉴얼 페이지 and 문서
+// 페이지, and 화면 also matches 화면 캡처. Paired with a making verb those will fire. They are
+// page- and screen-shaped enough that the guidance is not harmful, and the conjunction below — a
+// verb AND a noun — remains the real protection, exactly as it is in English.
+// 구현 (implement) and 인터페이스 (interface) are excluded for the same reason their English
+// counterparts are: in a typed language those words are about types, not screens.
+// structural-search is intent-shaped for the same reason frontend-ui-ux is: nobody types the skill
+// name. The conjunction is a search-or-rewrite verb AND a noun naming a SYNTAX SHAPE, because either
+// alone is far too common — "find the bug" and "the imports are messy" must both stay inert.
+//
+// THE TWO HALVES ARE DELIBERATELY ASYMMETRIC, and widening them is not equally safe.
+// The shape half can be extended freely: the verb half is what rejects "check the call site of this
+// bug" and "this declaration is in the wrong file", so adding a near-synonym noun costs nothing.
+// The verb half CANNOT be widened the same way. Measured: adding `check` and `update` to it turns 2
+// of 7 adversarial prompts into false positives, because compiler vocabulary appears just as often
+// in requests that merely DISCUSS a construct as in requests to MATCH one.
+// The accepted consequence is a known miss: "show me the call graph" and "list all callers" stay
+// silent because `show` and `list` are not search verbs here. A missed structural request costs a
+// user one rephrase; a false positive injects a skill into unrelated work. Closeout section 19i
+// records the class this vocabulary approach cannot close.
+const structuralVerb = /(?<![a-z])(?:find|locate|search|rewrite|replace|migrate|codemod)(?![a-z])/u;
+// The shape half admits SYNTACTIC terms only. skills/structural-search/SKILL.md:148 draws the line
+// this list must obey — "ask the language server who and what, ask a structural engine what shape" —
+// and :149 names the case explicitly: "Finding every caller of a function is a language-server
+// question." So callers, call graph, invocations, references to, and usages of are all WHO questions
+// and were removed: the router must not contradict the skill's own routing table. Bare `signatures`
+// went too, but for a different reason — it fires on "search the changelog for signatures", which is
+// cryptography, not code. The qualified form keeps the real case.
+const structuralShape = /(?<![a-z])(?:call ?sites?|callsites?|declarations?|import statements?|imports|(?:function|method) signatures?|syntax shapes?|syntax trees?|ast)(?![a-z])/u;
+const uiIntentVerb = /(?<![a-z])(?:design|redesign|restyle|revamp|polish|lay\s?out|mock\s?up|build|create|make)(?![a-z])|디자인|만들|제작|개편|다듬|꾸미/u;
+const uiIntentNoun = /(?<![a-z])(?:ui|ux|user interface|screen|page|layout|dashboard|modal|navbar|sidebar|stylesheet|css|design system|landing page|front[- ]?end|component)(?![a-z])|화면|페이지|레이아웃|대시보드|컴포넌트|모달|사이드바|내비게이션|네비게이션|스타일시트|디자인 시스템|랜딩 페이지|프런트엔드|프론트엔드/u;
+const litSlashCommands = Object.freeze([
+    ...Object.values(renamedSkillIds),
+    "lit-burnoff-file",
+    "lit-fetch",
+    "lit",
+    "lit-loop",
+    "lit-plan",
+    "litwork",
+    "lit-work",
+    "start-work",
+    "review-work",
+    "lit-research",
+    "litresearch",
+    "lit-goal",
+    "litgoal",
+    "lit-init",
+    "lit-crucible",
+    "refactor",
+    "lit-burnoff",
+    "lit-code",
+    "debugging",
+    "lit-commit",
+    "lsp",
+    "lsp-setup",
+    "rules",
+    "deep-interview",
+    "structural-search",
+    "browser-drive",
+    "skill-observer",
+    "lit-recap",
+    "lit-comprehend",
+    "lit-handoff",
+    "lit-scientific-visualization",
+    "lit-korean",
+    "text-neutralization",
+    "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 function containsStandaloneLitTrigger(text) {
+    return detectChatActivationMode(text) !== undefined;
+}
+function withoutInactiveContent(text) {
+    return text
+        .replace(/```[\s\S]*?```/g, " ")
+        .replace(/`[^`]*`/g, " ")
+        .replace(/^\s*>.*$/gmu, " ")
+        .replace(/"[^"\r\n]*"/gu, " ")
+        .replace(/“[^”\r\n]*”|‘[^’\r\n]*’/gu, " ")
+        .replace(/(^|[\s([{])'[^'\r\n]*'(?=$|[\s)\]},.!?;:])/gmu, "$1 ");
+}
+function normalizedTriggerText(text) {
+    return withoutInactiveContent(text).toLowerCase().replace(/[_-]+/g, " ");
+}
+function rawTriggerText(text) {
+    return withoutInactiveContent(text).toLowerCase();
+}
+function hasLitTrigger(text) {
+    return containsCompoundBoundedWord(text, "lit") || containsCompoundBoundedWord(text, "litwork") || containsCompoundBoundedWord(text, "litopencode");
+}
+function containsRecapTrigger(text) {
+    return recapBoundedWords.some((word) => containsCompoundBoundedWord(text, word, recapWordCharacter));
+}
+function routeWords(text) {
+    return text.match(/[a-z0-9]+/g) ?? [];
+}
+function containsLitRoute(words, ...route) {
+    for (let index = 0; index < words.length; index += 1) {
+        if (!routeTriggerWords.includes(words[index]))
+            continue;
+        if (route.every((word, offset) => words[index + offset + 1] === word))
+            return true;
+    }
+    return false;
+}
+function startsWithStartWorkInvocation(raw, normalized) {
+    const rawStart = raw.trimStart();
+    if (/^start-work(?:$|[\s,.:;!?])/u.test(rawStart))
+        return true;
+    return /^lit\s+start\s+work(?:$|[\s,.:;!?])/u.test(normalized.trimStart());
+}
+function endsWithStandaloneLitInvocation(raw) {
+    return /(?:^|\s)lit[.!?]*$/u.test(raw.trim());
+}
+function containsLitSlashCommandMention(text) {
+    const mentions = text.match(/(^|\s)\/([A-Za-z][\w-]*)/gu) ?? [];
+    return mentions.some((mention) => litSlashCommands.includes(mention.trim().slice(1)));
+}
+export function detectChatActivationMode(text, agent) {
+    if (text.trim().toLowerCase() === "handoff")
+        return "lit-handoff";
+    if (text.trim().toLowerCase() === "lit-scientific-visualization")
+        return "lit-scientific-visualization";
+    const raw = rawTriggerText(text);
+    const normalized = normalizedTriggerText(text);
+    const words = routeWords(normalized);
+    if (containsLitSlashCommandMention(raw))
+        return undefined;
+    const workflowFamilyMode = detectWorkflowFamilyChatMode(raw);
+    if (workflowFamilyMode !== undefined)
+        return workflowFamilyMode;
+    if (containsRenamedSkillTrigger(raw, "lit-crucible"))
+        return "lit-crucible";
+    if (containsRenamedSkillTrigger(raw, "lit-init"))
+        return "lit-init";
+    if (/^(?:litresearch|lit-research)(?:$|[\s,.:;!?])/u.test(raw.trimStart()))
+        return "lit-research";
+    if (startsWithStartWorkInvocation(raw, normalized))
+        return "start-work";
+    if (containsCompoundBoundedWord(raw, "review-work"))
+        return "review-work";
+    if (containsCompoundBoundedWord(raw, "litgoal") || containsCompoundBoundedWord(raw, "lit-goal"))
+        return "lit-goal";
+    if (containsRecapTrigger(raw))
+        return "lit-recap";
+    if (containsCompoundBoundedWord(raw, "lit-comprehend"))
+        return "lit-comprehend";
+    if (containsCompoundBoundedWord(raw, "lit comprehend"))
+        return "lit-comprehend";
+    if (containsCompoundBoundedWord(raw, "$lit-comprehend"))
+        return "lit-comprehend";
+    if (containsCompoundBoundedWord(raw, "comprehend"))
+        return "lit-comprehend";
+    if (containsCompoundBoundedWord(raw, "$comprehend"))
+        return "lit-comprehend";
+    if (containsRenamedSkillTrigger(raw, "lit-burnoff"))
+        return "lit-burnoff";
+    if (containsRenamedSkillTrigger(raw, "lit-commit"))
+        return "lit-commit";
+    if (containsCompoundBoundedWord(raw, "refactor"))
+        return "refactor";
+    if (containsRenamedSkillTrigger(raw, "lit-code"))
+        return "lit-code";
+    if (containsRenamedSkillTrigger(raw, "lit-burnoff-file"))
+        return "lit-burnoff-file";
+    if (containsRenamedSkillTrigger(raw, "lit-fetch"))
+        return "lit-fetch";
+    if (containsRenamedSkillTrigger(raw, "lit-korean"))
+        return "lit-korean";
+    if (containsCompoundBoundedWord(raw, "deep-interview"))
+        return "deep-interview";
+    if (containsCompoundBoundedWord(raw, "debugging"))
+        return "debugging";
+    // lsp-setup is checked first for readability; the compound boundary already keeps the two apart,
+    // because the hyphen in `lsp-setup` is itself a word character for this matcher.
+    if (containsCompoundBoundedWord(raw, "lsp-setup"))
+        return "lsp-setup";
+    if (containsCompoundBoundedWord(raw, "lsp"))
+        return "lsp";
+    if (containsCompoundBoundedWord(raw, "structural-search"))
+        return "structural-search";
+    // browser-drive is name-only on purpose. A prompt that merely mentions a browser, a URL, or the
+    // web is not a request to drive one, and over-firing is a recorded defect shape in this family.
+    if (containsCompoundBoundedWord(raw, "browser-drive"))
+        return "browser-drive";
+    // skill-observer is name-only for the same reason: "observe", "review", and "the skill fell
+    // short" are ordinary English about ordinary work, not a request to record a proposal.
+    if (containsCompoundBoundedWord(raw, "skill-observer"))
+        return "skill-observer";
+    if (structuralVerb.test(raw) && structuralShape.test(raw))
+        return "structural-search";
+    // visual-qa is name-shaped: the id is distinctive enough to be its own trigger, hyphenated or spaced.
+    if (containsCompoundBoundedWord(raw, "visual-qa") || containsCompoundBoundedWord(raw, "visual qa"))
+        return "visual-qa";
+    if (containsCompoundBoundedWord(raw, "frontend-ui-ux"))
+        return "frontend-ui-ux";
+    if (uiIntentVerb.test(raw) && uiIntentNoun.test(raw))
+        return "frontend-ui-ux";
+    if (!hasLitTrigger(raw))
+        return undefined;
+    if (containsLitRoute(words, "review"))
+        return "review-work";
+    if (containsLitRoute(words, "research"))
+        return "lit-research";
+    if (containsLitRoute(words, "goal"))
+        return "lit-goal";
+    if (containsLitRoute(words, "plan"))
+        return "lit-plan";
+    if ((containsCompoundBoundedWord(raw, "start-work") || containsLitRoute(words, "start", "work")) &&
+        !endsWithStandaloneLitInvocation(raw))
+        return undefined;
+    return agent === "lit-plan" ? "lit-plan" : "lit-loop";
+}
+export function promptForChatActivationMode(mode, triggerText = "") {
+    const prompt = canonicalChatPrompt(mode);
+    const raw = rawTriggerText(triggerText);
+    const alias = Object.keys(renamedSkillIds).find((id) => id === mode && containsCompoundBoundedWord(raw, renamedSkillIds[id]));
+    return alias === undefined ? prompt : `${skillRenameNote(alias)}\n${prompt}`;
+}
+function canonicalChatPrompt(mode) {
+    if (isWorkflowFamilyMode(mode))
+        return workflowFamilyPrompt(mode);
+    switch (mode) {
+        case "lit-loop":
+            return litLoopPromptInjection;
+        case "lit-plan":
+            return litPlanPromptInjection;
+        case "start-work":
+            return startWorkChatPromptInjection;
+        case "review-work":
+            return reviewWorkPromptInjection;
+        case "lit-research":
+            return litResearchPromptInjection;
+        case "lit-goal":
+            return litGoalPromptInjection;
+        case "lit-init":
+            return initDeepPromptInjection;
+        case "lit-burnoff-file":
+            return litBurnoffFilePromptInjection;
+        case "lit-fetch":
+            return litFetchPromptInjection;
+        case "lit-korean":
+            return textNaturalizationPromptInjection;
+        case "lit-crucible":
+            return litCruciblePromptInjection;
+        case "refactor":
+            return refactorPromptInjection;
+        case "lit-burnoff":
+            return removeAiSlopsPromptInjection;
+        case "lit-code":
+            return litCodePromptInjection;
+        case "debugging":
+            return debuggingPromptInjection;
+        case "lit-commit":
+            return gitMasterPromptInjection;
+        case "lsp":
+            return lspPromptInjection;
+        case "lsp-setup":
+            return lspSetupPromptInjection;
+        case "deep-interview":
+            return deepInterviewPromptInjection;
+        case "structural-search":
+            return structuralSearchPromptInjection;
+        case "browser-drive":
+            return browserDrivePromptInjection;
+        case "skill-observer":
+            return skillObserverPromptInjection;
+        case "frontend-ui-ux":
+            return frontendUiUxPromptInjection;
+        case "visual-qa":
+            return visualQaPromptInjection;
+        case "lit-recap":
+            return litRecapPromptInjection;
+        case "lit-comprehend":
+            return comprehendPromptInjection;
+        case "lit-handoff":
+            return litHandoffPromptInjection;
+        case "lit-scientific-visualization":
+            return scientificVisualizationPromptInjection;
+    }
+}
+function containsRenamedSkillTrigger(text, id) {
+    return containsCompoundBoundedWord(text, id) || containsCompoundBoundedWord(text, renamedSkillIds[id]);
+}
+function containsCompoundBoundedWord(text, word, wordCharacter = compoundWordBoundary) {
+    for (let index = 0; index < text.length; index += 1) {
+        if (!text.startsWith(word, index))
+            continue;
+        const previous = index === 0 ? undefined : text[index - 1];
+        const next = text[index + word.length];
+        if (isCompoundWordBoundary(previous, wordCharacter) && isCompoundWordBoundary(next, wordCharacter))
+            return true;
+    }
+    return false;
+}
+function isCompoundWordBoundary(value, wordCharacter) {
+    return value === undefined || !wordCharacter.test(value);
+}

package/dist/activation-workflow-prompts.d.ts

@@ -0,0 +1,26 @@
+export declare const startWorkPromptInjection: string;
+export declare const startWorkChatPromptInjection: string;
+export declare const reviewWorkPromptInjection: string;
+export declare const litResearchPromptInjection: string;
+export declare const litGoalPromptInjection: string;
+export declare const litCruciblePromptInjection: string;
+export declare const initDeepPromptInjection: string;
+export declare const refactorPromptInjection: string;
+export declare const removeAiSlopsPromptInjection: string;
+export declare const litCodePromptInjection: string;
+export declare const gitMasterPromptInjection: string;
+export declare const debuggingPromptInjection: string;
+export declare const lspPromptInjection: string;
+export declare const lspSetupPromptInjection: string;
+export declare const rulesPromptInjection: string;
+export declare const deepInterviewPromptInjection: string;
+export declare const frontendUiUxPromptInjection: string;
+export declare const browserDrivePromptInjection: string;
+export declare const skillObserverPromptInjection: string;
+export declare const visualQaPromptInjection: string;
+export declare const structuralSearchPromptInjection: string;
+export declare const litRecapPromptInjection: string;
+export declare const comprehendPromptInjection: string;
+export declare const textNaturalizationPromptInjection: string;
+export declare const litBurnoffFilePromptInjection: string;
+export declare const litFetchPromptInjection: string;