@litfamily/litopencode 1.0.31 → 1.0.32

package/dist/v2/session-hooks.js

@@ -6,12 +6,14 @@
 // 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 { typedPromptReply } from "../adhd-next.js";
+import { createActivationMemory, decideReentry, recordActivation } from "../activation-reentry.js";
 import { detectChatActivationMode, promptForChatActivationMode } from "../activation-routing.js";
-import { startWorkPromptInjection } from "../activation-workflow-prompts.js";
+import { adhdSessionNote, litAdhdPromptInjection, 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 { startTypedWork, typedStartArgument } from "../start-work-typed.js";
 import { createLitGoalOperations } from "../ledger.js";
 import { applyCompactionRuleReset, applyStaticRuleInjection } from "../rules/hooks.js";
 import { isReadOnlyWorkflowFamilyPlan } from "../workflow-families.js";
@@ -125,13 +127,42 @@ export function createV2SessionHooks(options) {
         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 typed = await typedPromptReply(options.projectRoot, event.sessionID, input, activationMemory, options.config.boundedAuthority);
+        if (typed !== undefined) {
+            state.turn.push(typed.text);
+            event.metadata = { ...(event.metadata ?? {}), litopencode: { mode: typed.mode, trigger: "lit", source: "prompt", typed: typed.kind } };
+            if (typed.continued)
+                options.onActivation?.(event.sessionID, typed.mode);
+            return;
+        }
+        // An installed alias file makes the host expand /lit-adhd (or /lit-rewind) itself, so the prompt
+        // arrives as the command body with no plugin mark; it still runs the brief and takes its look.
+        if (input.trimStart().startsWith(litAdhdPromptInjection.trim())) {
+            state.turn.push(adhdSessionNote(event.sessionID));
+            event.metadata = { ...(event.metadata ?? {}), litopencode: { mode: "lit-adhd", trigger: "lit", source: "alias" } };
+            options.onActivation?.(event.sessionID, "lit-adhd");
+            return;
+        }
         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 === "lit-adhd")
+            activation = `${activation}\n${adhdSessionNote(event.sessionID)}`;
         if (mode === "start-work" && session.agent !== "lit-plan") {
             const directive = parseStartWorkLifecycleDirective(input, { chat: true });
+            const planArgument = directive === undefined ? typedStartArgument(input) : undefined;
+            if (planArgument !== undefined) {
+                const started = await startTypedWork({
+                    projectRoot: options.projectRoot,
+                    sessionID: event.sessionID,
+                    ...(planArgument === "" ? {} : { plan: planArgument }),
+                    options: options.config.boundedAuthority
+                });
+                if (started.quiet !== true)
+                    state.user.push(started.text);
+            }
             if (directive?.action === "resume") {
                 try {
                     const receipt = await applyTrustedStartWorkDirective(options.projectRoot, event.sessionID, directive, options.config.boundedAuthority);
@@ -160,15 +191,17 @@ export function createV2SessionHooks(options) {
             activation = `${reentry.line}\n${activation}`;
         else if (reentry.kind === "confirm")
             activation = `${activation}\n${reentry.line}`;
+        if (reentry.kind !== "confirm" && mode !== "lit-handoff" && mode !== "lit-scientific-visualization") {
+            const recorded = await recordActivation({ memory: activationMemory, projectRoot: options.projectRoot, sessionID: event.sessionID, mode });
+            if (recorded.line !== undefined)
+                activation = `${activation}\n${recorded.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 {

package/dist/workflow-stack.d.ts

@@ -0,0 +1,53 @@
+export declare const workflowStackSchema = "litopencode.workflow-stack/v1";
+export type FrameStatus = "active" | "paused";
+export type StackFrame = {
+    readonly skill: string;
+    readonly status: FrameStatus;
+    readonly at: number;
+    readonly phase?: string;
+    /** Both counts or neither: an unknown total is never stored as zero. */
+    readonly done?: number;
+    readonly total?: number;
+};
+export type WorkflowStack = {
+    readonly schema: typeof workflowStackSchema;
+    readonly sessionID: string;
+    readonly frames: readonly StackFrame[];
+    readonly updatedAt: number;
+};
+export type FrameProgress = {
+    readonly phase?: string;
+    readonly done?: number;
+    readonly total?: number;
+};
+export declare function isSpineSkill(skill: string): boolean;
+export declare function emptyStack(sessionID: string): WorkflowStack;
+/** A new spine skill ends whatever the stack held: the user moved on to a different discipline. */
+export declare function startSpine(stack: WorkflowStack, skill: string, now: number): WorkflowStack;
+/** Records the spine's progress without pausing it, so a later pause or a card read has real numbers. */
+export declare function pauseSpine(stack: WorkflowStack, now: number, progress?: FrameProgress): WorkflowStack;
+/**
+ * Starts a side skill. An active spine is paused under it, keeping its stage and counts; a second side
+ * skill replaces the first. With no spine the side skill stands alone.
+ */
+export declare function pushSide(stack: WorkflowStack, skill: string, now: number, progress: FrameProgress | undefined): WorkflowStack;
+/** Closes the side frame and makes the paused spine active again at the stage it was paused in. */
+export declare function resumeSpine(stack: WorkflowStack, now: number): {
+    readonly stack: WorkflowStack;
+    readonly resumed?: StackFrame;
+};
+export declare function stackFile(projectRoot: string, sessionID: string): string;
+/** The session's stack, or undefined when the id is unsafe, the file is missing, a link, oversized or malformed. */
+export declare function readStack(projectRoot: string, sessionID: string): Promise<WorkflowStack | undefined>;
+export declare function writeStack(projectRoot: string, stack: WorkflowStack): Promise<void>;
+export type SiblingOptions = {
+    readonly now: number;
+    readonly freshMs: number;
+    readonly max: number;
+};
+/** Other sessions' stacks that moved recently, for the thread rows. Links and the session's own file are skipped. */
+export declare function readSiblingStacks(projectRoot: string, selfID: string, options: SiblingOptions): Promise<readonly WorkflowStack[]>;
+/** The TUI reads on its own refresh and cannot await: the same checks as `readStack`, synchronously. */
+export declare function readStackSync(projectRoot: string, sessionID: string): WorkflowStack | undefined;
+/** Synchronous twin of `readSiblingStacks`. */
+export declare function readSiblingStacksSync(projectRoot: string, selfID: string, options: SiblingOptions): readonly WorkflowStack[];

package/dist/workflow-stack.js

@@ -0,0 +1,196 @@
+import { lstatSync, readFileSync, readdirSync } from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { createRuntimePaths } from "./state.js";
+// A session's workflow stack: the discipline it is running (the spine) and, while another lit command
+// is interjected, the paused spine underneath it. An interjected command pauses the spine and never
+// erases it, so `lit continue` returns to the same stage and the same k/n. Transitions are pure; the
+// store keeps one small JSON file per session so the TUI band and a restarted plugin read the same
+// record.
+export const workflowStackSchema = "litopencode.workflow-stack/v1";
+const spineSkills = new Set(["lit-loop", "lit-plan", "start-work", "lit-task"]);
+const safeSessionID = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/u;
+const stackByteLimit = 64 * 1024;
+const frameLimit = 4;
+export function isSpineSkill(skill) {
+    return spineSkills.has(skill);
+}
+export function emptyStack(sessionID) {
+    return { schema: workflowStackSchema, sessionID, frames: [], updatedAt: 0 };
+}
+function counts(progress) {
+    const done = progress?.done;
+    const total = progress?.total;
+    return Number.isInteger(done) && Number.isInteger(total) && total > 0 && done >= 0 && done <= total
+        ? { done: done, total: total }
+        : {};
+}
+function frame(skill, status, at, progress) {
+    return { skill, status, at, ...(progress?.phase === undefined ? {} : { phase: progress.phase }), ...counts(progress) };
+}
+function withFrames(stack, frames, now) {
+    return { ...stack, frames: frames.slice(-frameLimit), updatedAt: now };
+}
+/** A new spine skill ends whatever the stack held: the user moved on to a different discipline. */
+export function startSpine(stack, skill, now) {
+    return withFrames(stack, [frame(skill, "active", now)], now);
+}
+/** Records the spine's progress without pausing it, so a later pause or a card read has real numbers. */
+export function pauseSpine(stack, now, progress) {
+    const [spine, ...rest] = stack.frames;
+    if (spine === undefined || !isSpineSkill(spine.skill))
+        return stack;
+    return withFrames(stack, [frame(spine.skill, "paused", spine.at, { phase: progress?.phase ?? spine.phase, done: progress?.done ?? spine.done, total: progress?.total ?? spine.total }), ...rest], now);
+}
+/**
+ * Starts a side skill. An active spine is paused under it, keeping its stage and counts; a second side
+ * skill replaces the first. With no spine the side skill stands alone.
+ */
+export function pushSide(stack, skill, now, progress) {
+    const spine = stack.frames.find((candidate) => isSpineSkill(candidate.skill));
+    if (spine === undefined)
+        return withFrames(stack, [frame(skill, "active", now)], now);
+    const paused = pauseSpine({ ...stack, frames: [spine] }, now, progress).frames[0];
+    return withFrames(stack, [paused, frame(skill, "active", now)], now);
+}
+/** Closes the side frame and makes the paused spine active again at the stage it was paused in. */
+export function resumeSpine(stack, now) {
+    const spine = stack.frames.find((candidate) => isSpineSkill(candidate.skill) && candidate.status === "paused");
+    if (spine === undefined)
+        return { stack };
+    const resumed = { ...spine, status: "active" };
+    return { stack: withFrames(stack, [resumed], now), resumed };
+}
+export function stackFile(projectRoot, sessionID) {
+    if (!safeSessionID.test(sessionID))
+        throw new Error("workflow stack session id must match [A-Za-z0-9_-]");
+    return path.join(createRuntimePaths(projectRoot).workflowStackDir, `${sessionID}.json`);
+}
+function isFrame(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const record = value;
+    const optionalInt = (field) => field === undefined || (Number.isInteger(field) && field >= 0);
+    return typeof record.skill === "string" && (record.status === "active" || record.status === "paused") && Number.isFinite(record.at) &&
+        (record.phase === undefined || typeof record.phase === "string") && optionalInt(record.done) && optionalInt(record.total);
+}
+async function readRegular(file) {
+    try {
+        const stat = await fs.lstat(file);
+        if (!stat.isFile() || stat.size > stackByteLimit)
+            return undefined;
+        return await fs.readFile(file, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseStack(text, sessionID) {
+    if (text === undefined)
+        return undefined;
+    let value;
+    try {
+        value = JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+    if (typeof value !== "object" || value === null)
+        return undefined;
+    const record = value;
+    if (record.schema !== workflowStackSchema || record.sessionID !== sessionID || !Array.isArray(record.frames) || !record.frames.every(isFrame) || !Number.isFinite(record.updatedAt))
+        return undefined;
+    return { schema: workflowStackSchema, sessionID, frames: record.frames.slice(-frameLimit), updatedAt: record.updatedAt };
+}
+/** The session's stack, or undefined when the id is unsafe, the file is missing, a link, oversized or malformed. */
+export async function readStack(projectRoot, sessionID) {
+    if (!safeSessionID.test(sessionID))
+        return undefined;
+    return parseStack(await readRegular(stackFile(projectRoot, sessionID)), sessionID);
+}
+export async function writeStack(projectRoot, stack) {
+    const file = stackFile(projectRoot, stack.sessionID);
+    const dir = path.dirname(file);
+    await fs.mkdir(dir, { recursive: true });
+    const dirStat = await fs.lstat(dir);
+    if (!dirStat.isDirectory())
+        throw new Error("workflow stack directory is not a directory");
+    try {
+        if ((await fs.lstat(file)).isSymbolicLink())
+            throw new Error("workflow stack file is a link");
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    const temp = `${file}.${process.pid}.tmp`;
+    await fs.writeFile(temp, `${JSON.stringify(stack)}\n`, { mode: 0o600 });
+    await fs.rename(temp, file);
+}
+/** Other sessions' stacks that moved recently, for the thread rows. Links and the session's own file are skipped. */
+export async function readSiblingStacks(projectRoot, selfID, options) {
+    const dir = createRuntimePaths(projectRoot).workflowStackDir;
+    let names;
+    try {
+        names = await fs.readdir(dir);
+    }
+    catch {
+        return [];
+    }
+    const found = [];
+    for (const name of names.sort()) {
+        if (!name.endsWith(".json"))
+            continue;
+        const sessionID = name.slice(0, -".json".length);
+        if (sessionID === selfID || !safeSessionID.test(sessionID))
+            continue;
+        const stack = parseStack(await readRegular(path.join(dir, name)), sessionID);
+        if (stack === undefined || stack.frames.length === 0 || options.now - stack.updatedAt > options.freshMs)
+            continue;
+        found.push(stack);
+        if (found.length >= options.max)
+            break;
+    }
+    return found;
+}
+function readRegularSync(file) {
+    try {
+        const stat = lstatSync(file);
+        return stat.isFile() && stat.size <= stackByteLimit ? readFileSync(file, "utf8") : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The TUI reads on its own refresh and cannot await: the same checks as `readStack`, synchronously. */
+export function readStackSync(projectRoot, sessionID) {
+    if (!safeSessionID.test(sessionID))
+        return undefined;
+    return parseStack(readRegularSync(stackFile(projectRoot, sessionID)), sessionID);
+}
+/** Synchronous twin of `readSiblingStacks`. */
+export function readSiblingStacksSync(projectRoot, selfID, options) {
+    const dir = createRuntimePaths(projectRoot).workflowStackDir;
+    let names;
+    try {
+        names = readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    const found = [];
+    for (const name of names.sort()) {
+        if (!name.endsWith(".json"))
+            continue;
+        const sessionID = name.slice(0, -".json".length);
+        if (sessionID === selfID || !safeSessionID.test(sessionID))
+            continue;
+        const stack = parseStack(readRegularSync(path.join(dir, name)), sessionID);
+        if (stack === undefined || stack.frames.length === 0 || options.now - stack.updatedAt > options.freshMs)
+            continue;
+        found.push(stack);
+        if (found.length >= options.max)
+            break;
+    }
+    return found;
+}

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

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

package/docs/reference-Ko-KR.md

@@ -140,6 +140,8 @@ litopencode install
 | `/review-work` | `lit-plan` 뒤에는 계획 검토, `lit-loop`나 `/start-work` 뒤에는 작업 검토. 있는 것을 보고 고르며 `/review-work plan`, `/review-work work`로 직접 정할 수 있음 |
 | `/litgoal` | 끝나는 지점을 정하고 지킴: 확인 가능한 기준이 붙은 목표 하나를 디스크에 남김. `lit-loop`와 `/start-work`가 그 목표를 향해 일함 |
 | `/lit-brainstorm` | 열린 질문을 여러 선택지로 펼친 뒤 짧은 목록으로 좁히고, 고른 것을 `deep-interview`나 `lit-plan`에 넘김. 채팅에서는 `lit brainstorm`, `lit brainstorming`, `lit ideation`, `lit ideate`, `lit idea`, `lit ideas`. 직접 만들지는 않음 |
+| `/lit-hijack` | 다른 사람이 공개한 작업의 기법 원리를 내 스킬이나 시스템에 옮김: 출처 기록, 라이선스 확인, 격차 분석, 원문 없는 명세, 분리된 구현, 동작 비교, 보고서. 각 단계의 완료는 동봉된 `hijack.mjs`가 판정함. 채팅에서는 `lit hijack`, `lit hijacking`, `lit 하이재킹`, `lit 하이잭` |
+| `/lit-adhd`, `/lit-rewind` | 하던 일을 이어서 시작: 이전 세션의 상태, 실제 진행 또는 아는 사실, 로드맵, 추천 한 단계를 읽기 전용으로 보여 줌. 동봉된 `rewind.mjs`가 수집함. 채팅에서는 `lit adhd`, `lit rewind`, 이어서 `go`가 30분간 준비된 단계를 따라감. `lit approve`와 `lit deny`는 대기 중인 경계에 답하고, `lit deny`는 실행을 끝냄. |
 | `/litresearch` 또는 `/lit-research` | 순차 대체 경로를 포함한 근거 기반 연구 |
 | `/lit-handoff` | 이어서 작업할 수 있는 핸드오프 작성 |
 | `/lit-recap` | 로컬 ledger와 세션 맥락으로 짧은 리캡 작성 |
@@ -405,6 +407,28 @@ OpenCode 1.18은 `tui.json`이나 `tui.jsonc`의 `plugin` 배열에 적힌 TUI
     자리가 모자라면 남은 칩을 `+N`으로 접습니다.
   - 아래 테두리에는 context 사용량(75%부터 주황), 첫 lit 턴부터 지난 시간(`⟳ 7m`), git 브랜치가
     붙습니다.
+  - 나란히 도는 작업이 둘 이상이면 스킬 칩 줄 아래에 줄이 늘어납니다. `┬ 3 lanes in parallel` 다음에
+    작업마다 `├─`/`└─` 한 줄씩입니다(이 세션의 워크플로 스택 항목, 실행 중인 `task` 호출, 최근 15분
+    안에 스택이 움직인 같은 작업 공간의 다른 세션). 최대 네 줄이고 나머지는 `+N more`입니다. 줄마다 이름,
+    상태 단어(`working`, `paused`, `done`, `failed`, `idle`), 그리고 실제 총량이 있을 때만 게이지
+    (`[▉▉░░░░░░] 3/10`)가 붙습니다. 총량을 모르면 아는 것(단계, 걸린 시간)을 글로 쓰고 일하는 중이면 작은
+    펄스를 보여 줄 뿐 물음표는 쓰지 않습니다. 작업이 살아 있는 동안 카드는 가장 높았던 높이를 유지하고,
+    모두 가라앉으면 네 줄로 돌아옵니다.
+  - `lit-adhd`(별칭 `lit-rewind`)가 도는 동안 테두리, LIT 글자, 게이지가 같은 밝기의 색상환을 따라 돕니다.
+    1초에 네 번 색이 조금씩 바뀌고 깜박이지 않습니다. `motion: false`와 `NO_COLOR`에서는 꺼집니다. 이전
+    작업이 있는 작업 공간의 쉬는 세션은 `lit adhd to pick up where you left off`를 보여 주고, 그곳에서 처음 연
+    새 세션은 같은 문구로 토스트를 한 번 띄웁니다(v1 TUI만. v2 TUI에는 띠도 토스트도 없습니다).
+  - 카드의 모양은 한 번에 하나이고, `src/tui/mission-looks.ts`의 작은 목록에서 고릅니다. lit-adhd를 실행하는
+    길은 모두 되감기 모양이 됩니다. 채팅의 `lit adhd`/`lit rewind`, `/lit-adhd`/`/lit-rewind`(v2에 설치된 별칭
+    파일에서 온 것도 포함), 네이티브 `skill` 로드가 그렇습니다. 세션이 사용자를 기다리는 동안(권한 요청이나 질문,
+    또는 목표 결정, `BLOCKED:`로 시작하는 답, 경계에서 멈춘 타이핑 start-work 실행으로 끝난 쉬는 턴) 테두리가
+    주황빛이 되고 모서리에 `◆ YOUR TURN`이 뜹니다. 주황빛은 3초 호흡으로 천천히 바뀌고 깜박이지 않으며,
+    `motion: false`와 `NO_COLOR`에서는 멈춰 있고, 사용자가 입력하면 꺼집니다. `review-work`가 도는 동안에는
+    위 테두리가 다섯 갈래(scope, tests, package, security, surface)로 나뉘고 모서리에 `◇ REVIEW 2/5`처럼 보고된
+    수를 셉니다. 에이전트가 `review-work` 도구(`action: "lane"`, 갈래 이름, `pass`·`fail`·`blocked`)로 보고한
+    뒤에만 그 갈래가 켜집니다. 실패한 갈래는 오류 색이 되고, 보고되지 않은 갈래는 흐리게 남습니다. 목표가 끝나면
+    완료 불꽃이 한 번 터지고 카드가 가라앉으며, 평소 턴에서는 다시 터지지 않습니다. 릴리스 게시는 카드가 받는
+    신호가 없어서 불꽃도 없습니다.
 
   하위(subagent) 세션에서는 부모 세션의 카드를 `· in lane`과 함께 보여 주고, 홈 화면에는 띠가
   없습니다. 폭이 좁으면 줄마다 덜 중요한 것부터 덜어 냅니다. 단계 줄은 지금 하는 일과 다음 할 일
@@ -640,10 +664,14 @@ Install은 `<root>/skills`가 심볼릭 링크여도(예: `~/.config/opencode/sk
 
 ## 디자인 제작과 README
 
-OpenCode 네이티브 스킬 `frontend-ui-ux`는 충분한 구현 요청을 받으면 작업 화면을 만들고 렌더링을 확인합니다. 중요한 방향이 모호할 때만 질문하며 답변을 보존합니다. 검토·계획 요청은 읽기 전용입니다.
+OpenCode 네이티브 스킬 `frontend-ui-ux`는 충분한 구현 요청을 받으면 작업 화면을 만들고 렌더링을 확인합니다. 중요한 방향이 모호할 때만 질문하며 답변을 보존합니다. 검토·계획 요청은 읽기 전용입니다. 새 페이지나 화면은 `scripts/design-lock.mjs`로 룩(하우스 스타일, 레이아웃 계열, 시그니처 순간, 풍부 또는 차분한 밀도)을 먼저 고정합니다. 생성된 `design.lock.json`, `ui/tokens.css`, `ui/components.css`와 글꼴은 프로젝트에 놓이며, 글꼴은 sha256 확인 후 `lit-diagram-drawer`와 `lit-typographic-motion` 스킬에서 복사합니다. 락이 페이지 옆에 있으면 `scripts/probe.mjs`가 DS-001~DS-008과 LOOK-1~LOOK-6 질문을 더합니다. `--viewports`는 일부 뷰만 돌리며 승인하지 않습니다.
 
 네이티브 스킬 도구에서 `readme-studio`를 선택하면 실제 저장소 정보로 README와 표지를 제작합니다. 로컬 글꼴의 윤곽선, Remotion/HyperFrames 예제, 정적·동적 출력 절차가 함께 설치됩니다. 이미지 생성 도구가 없으면 `IMAGE_GENERATION_UNAVAILABLE`을 알리고 제공된 배경으로 이어갑니다. 공개 GitHub/npm 렌더링 검증은 별도 단계입니다. 전용 슬래시 명령은 없습니다.
 
+네이티브 스킬 `lit-typographic-motion`은 무대 영화에 이야기(`story`: 보는 사람의 기대, 반전, 반전이 떨어지는 샷, 결말)와 영화의 절반 이상에서 움직이는 주인공을 요구합니다. 요청에 링크가 있으면 제품이 필수입니다. `render.mjs assets --out <dir> --url <https 링크> [--cover]`가 페이지와 README를 신뢰할 수 없는 데이터로 읽어, 형식을 확인하고 크기를 제한한 이미지만(SVG는 정리, 배지는 제외) `stage/assets/` 또는 `cover/assets/`에 두며, 그 이미지를 한 번도 보여 주지 않는 영화는 `ASSET-USED` 게이트 행에서 실패합니다. 제품에 닿을 수 없으면 화면을 지어내지 않고 종료 코드 22로 사용자에게 묻습니다. `depth: "3d"`는 고정된 three.js r170(`/lit/three/`로 제공, 해시는 `THIRD_PARTY_NOTICES`)을 GPU 단계에서 쓰고, GPU가 시작되지 않으면 표시를 달아 SwiftShader로 내려갑니다. 사용자 그림이 없는 README 표지는 `hero-3d` 레시피를, `painted-light`는 사용자 그림이 있을 때만 씁니다. 영화는 기본적으로 풍부합니다(`register: rich`). 무대 영화는 화면을 채워야 하고(열두 구역 중 둘 넘게 비는 샷이 둘 이상이면 `RICH-FILL` 실패), 실제 이름의 촘촘한 라벨과 움직이는 카메라를 갖추며, 영화마다 겹겹의 점수(`sound.mode: score`; 킥·클랩·하이햇·퍼커션·베이스·코드·리드·fx·액센트 스템, 사이드체인, -16 LUFS, 이야기 박자에 떨어지는 드롭, 스템은 `sound/stems/`에 보관)를 받습니다. 차분하거나 미니멀한 영화를 요청할 때만 `minimal`이 됩니다. `render3d: "blender"`는 선택형 Cycles 플레이트 단계를 더하며(`render.mjs blender --out <dir> [--final] [--detach]`; `scaffold`가 `BLENDER:` 줄을 알리고, Blender가 없으면 표시를 달아 three.js로 내려갑니다), 보는 확인은 무대 경로에서 질문 11개(타입 경로와 표지는 9개)이며 영화가 자기 방식에 충분히 풍부한지, 반전이 닿는지를 묻습니다. `gate.mjs --done`은 폴더 위쪽에서 실행을 찾으므로 영화 폴더 안에서 `--out .`으로도 동작합니다. 트리트먼트 전에는 경로·스타일·형식·방식을 `question` 호출 한 번으로 묻고 규칙의 추천을 먼저 둡니다.
+
 개념·편집·기술 다이어그램은 `lit-diagram-drawer` 네이티브 스킬 선택기에서 제작하고 검증합니다. 제품 인터페이스는 `frontend-ui-ux`, 측정된 과학 데이터 그림은 `lit-scientific-visualization`을 사용합니다.
 
-`lit-docx`는 워드 보고서, `lit-pptx`는 파워포인트 발표자료를 만듭니다. `lit`과 함께 쓰면 요청한 형식의 네이티브 스킬을 선택하고, 마크다운 원본·품질 검사·렌더 확인을 유지합니다. 두 스킬은 만들기 전에 디자인 방향을 정하고 다른 후보 두 개와 함께 알려 줍니다. 발표자료는 Ledger, Signal, Atlas, Chalk, Paper, Gazette, Studio, Night 여덟 가지, 보고서는 Report, Brief, Manual, Proposal, Memo, Journal 여섯 가지 방향 중에서 고릅니다.
+실제 장비의 P&ID, PFD, 실험 장치 그림, 아이소메트릭 단면도는 `lit-schematic` 네이티브 스킬 선택기에서 제작하고 QA 스크립트와 렌더 확인으로 검증합니다. 범위가 분명한 도면 요청에 `lit`을 붙이면 그리기 전에 이 스킬을 불러오도록 안내합니다. 전용 슬래시 명령은 없습니다.
+
+`lit-docx`는 워드 보고서, `lit-pptx`는 파워포인트 발표자료를 만듭니다. `lit`과 함께 쓰면 요청한 형식의 네이티브 스킬을 선택하고, 마크다운 원본·품질 검사·렌더 확인을 유지합니다. 두 스킬은 만들기 전에 디자인 방향을 정하고 다른 후보 두 개와 함께 알려 줍니다. 발표자료는 Ledger, Signal, Atlas, Chalk, Paper, Gazette, Studio, Night, Computational Brutalism, Neo-Brutalism, Bauhaus, Riso, Newsroom 열세 가지, 보고서는 Report, Brief, Manual, Proposal, Memo, Journal 여섯 가지 방향 중에서 고릅니다.

package/docs/reference.md

@@ -168,6 +168,8 @@ for an approved plan; `/review-work` checks the `DoneClaim` through a five-lane
 | `/review-work` | Plan review after `lit-plan` or work review after `lit-loop` or `/start-work`, picked from what exists; `/review-work plan` or `/review-work work` forces one. |
 | `/litgoal` | Set and keep the finish line: one goal with checkable criteria on durable state. `lit-loop` and `/start-work` run toward it. |
 | `/lit-brainstorm` | Open a question into options, narrow them to a short list, and hand the pick to `deep-interview` or `lit-plan`. Chat: `lit brainstorm`, `lit brainstorming`, `lit ideation`, `lit ideate`, `lit idea`, `lit ideas`. It never builds. |
+| `/lit-hijack` | 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. A bundled `hijack.mjs` decides when each phase is done. Chat: `lit hijack`, `lit hijacking`, `lit 하이재킹`, `lit 하이잭`. |
+| `/lit-adhd`, `/lit-rewind` | Pick up where you left off: a read-only brief of earlier sessions with status, real progress or known facts, a roadmap and one recommended step. A bundled `rewind.mjs` collects it. Chat: `lit adhd`, `lit rewind`; then `go` follows the armed step for 30 minutes. `lit approve` and `lit deny` answer a pending boundary; `lit deny` ends the run. |
 | `/litresearch` or `/lit-research` | Run evidence-backed research with a sequential fallback. |
 | `/lit-handoff` | Create a resumable handoff; exact bare `handoff` also routes here. |
 | `/lit-recap` | Read a concise recap from local ledger and session context. |
@@ -263,6 +265,8 @@ flowchart LR
 - <code>lit-commit</code>
 - <code>lit-crucible</code>
 - <code>lit-brainstorm</code>
+- <code>lit-hijack</code>
+- <code>lit-adhd</code>
 - <code>lit-init</code>
 - <code>lit-comprehend</code>
 - <code>lit-handoff</code>
@@ -270,6 +274,7 @@ flowchart LR
 - <code>lit-recap</code>
 - <code>lit-scientific-visualization</code>
 - <code>lit-diagram-drawer</code>
+- <code>lit-schematic</code>
 - <code>lit-pptx</code>
 - <code>lit-docx</code>
 - <code>lit-typographic-motion</code>
@@ -522,7 +527,32 @@ What it draws:
     gets a short light sweep as it arrives; when the turn ends they dim and stay as the recent list,
     newest first, and firing one again brightens it. Chips that do not fit collapse into `+N`;
   - the bottom border holds the context use (amber from 75%), the time since the first lit turn
-    (`⟳ 7m`) and the git branch.
+    (`⟳ 7m`) and the git branch;
+  - lanes of parallel work add rows under the skill row while two or more exist: `┬ 3 lanes in
+    parallel`, then one `├─`/`└─` row per lane (this session's workflow-stack frames, running `task`
+    calls and other sessions in the workspace whose stack moved in the last 15 minutes), four at
+    most and `+N more` for the rest. Each row has the lane name, a status word (`working`,
+    `paused`, `done`, `failed`, `idle`) and a gauge only when the lane has a real total
+    (`[▉▉░░░░░░] 3/10`); otherwise it says what is known (the stage, how long it has run) and a
+    working lane shows a small pulse, never a question mark. The card keeps its tallest height while
+    lanes are live and drops back to four rows once everything has settled;
+  - while `lit-adhd` (alias `lit-rewind`) runs, the border, the LIT word and the gauges cycle through
+    the colour wheel at one fixed lightness, four small colour steps a second with no flashing. It
+    is off under `motion: false` and `NO_COLOR`. An idle session in a workspace with earlier work
+    says `lit adhd to pick up where you left off`, and the first fresh session there raises one
+    toast with the same words (v1 TUI only; the v2 TUI has no band and no toast).
+  - one look at a time, picked from a small registry in `src/tui/mission-looks.ts`. Every route that runs
+    lit-adhd wears the rewind look: `lit adhd`/`lit rewind` in chat, `/lit-adhd`/`/lit-rewind` (also from an
+    installed v2 alias file) and a native `skill` load. While the session waits on you (a permission or a
+    question, or an idle turn that ended on a goal decision, a reply opening with `BLOCKED:`, or a typed
+    start-work run paused on a boundary) the border turns amber and the corner says `◆ YOUR TURN`; the
+    amber eases over a 3 s breath with no flashing, holds still under `motion: false` and `NO_COLOR`, and
+    stops once you type. While `review-work` runs, the top border splits into its five lanes (scope, tests,
+    package, security, surface) and the corner counts them, `◇ REVIEW 2/5`. A lane lights only after the
+    agent reports it with the `review-work` tool (`action: "lane"`, a lane and `pass`, `fail` or
+    `blocked`); a failed lane turns the error colour and an unreported one stays dim. When a goal reaches
+    done the completion sparks play once and the card settles; a routine turn never replays them. A
+    published release has no signal on the card, so it raises no burst;
 
   A subagent session shows its parent's card with `· in lane`; the home screen has no band. When the
   card is narrow each row drops its own low-priority parts: the track drops the live step and
@@ -771,6 +801,8 @@ unmanaged copy, or accept that OpenCode may prefer it over the LitOpenCode-manag
 
 ## Design production and README Studio
 
-The native `frontend-ui-ux` skill takes an adequate authorized build request through working implementation and rendered inspection. It asks only material design choices and retains answers; review and plan requests remain read-only.
+The native `frontend-ui-ux` skill takes an adequate authorized build request through working implementation and rendered inspection. It asks only material design choices and retains answers; review and plan requests remain read-only. A new page or screen locks its look first with `scripts/design-lock.mjs` (house style, layout family, signature moment, rich or calm density); the generated `design.lock.json`, `ui/tokens.css`, `ui/components.css` and fonts live in the project, fonts are copied from the `lit-diagram-drawer` and `lit-typographic-motion` skills after a sha256 check, and `scripts/probe.mjs` adds DS-001 to DS-008 and the LOOK-1 to LOOK-6 questions when the lock sits beside the page. `--viewports` runs a subset of the matrix and never approves.
 
 Select `readme-studio` through OpenCode's native skill tool for factual README writing and local cover composition. The installed resources include outlined typography helpers and pinned Remotion/HyperFrames recipes. Without a native image generator it reports `IMAGE_GENERATION_UNAVAILABLE` and can continue from a supplied background. Public GitHub/npm rendering is a separate gate. No dedicated slash command is claimed.
+
+The native `lit-typographic-motion` skill gives a stage film a story (`story`: what the viewer expects, the turn, the shot where it lands, the payoff) and a protagonist that acts across at least half of the film. A link in the request makes the product required: `render.mjs assets --out <dir> --url <https link> [--cover]` reads the page and its README as untrusted data and keeps only sniffed, size-capped images (SVG cleaned, badges skipped) under `stage/assets/` or `cover/assets/`, and the `ASSET-USED` gate row fails a film that never shows them; an unreachable product exits 22 and asks the user instead of drawing an invented screen. `depth: "3d"` draws with the pinned three.js r170 (served under `/lit/three/`, hashes in `THIRD_PARTY_NOTICES`) on the GPU rung, and a failed GPU start falls back, labelled, to SwiftShader. A README cover without user art takes the `hero-3d` recipe; `painted-light` needs user art. Films are rich by default (`register: rich`): a stage film must fill its frame (`RICH-FILL` fails when more than two of twelve regions stay empty in more than one shot), carry dense real labels and a moving camera, and takes a per-film layered score (`sound.mode: score`; kick, clap, hats, perc, bass, chords, lead, fx and accents stems, sidechained, -16 LUFS, the drop on the story beat, stems kept under `sound/stems/`); only a request for a calm or minimal film makes it `minimal`. `render3d: "blender"` adds an optional Cycles plate rung (`render.mjs blender --out <dir> [--final] [--detach]`; `scaffold` prints a `BLENDER:` line, and an absent Blender falls back to three.js with a labelled note). The look round asks 11 questions on the stage path (9 on the type path and for covers), including whether the film is rich enough for its register and whether the turn lands, and `gate.mjs --done` finds the run up the tree, so it works with `--out .` from inside the film folder. Before the treatment the skill makes one `question` call for path, style, format and register, with the rules' pick first.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@litfamily/litopencode",
-  "version": "1.0.31",
+  "version": "1.0.32",
   "description": "Workflow plugin for OpenCode: add lit to a prompt and the work is planned, built, checked and written down so the next session can pick it up.",
   "keywords": [
     "opencode",

package/skills/frontend-ui-ux/SKILL.md

@@ -36,9 +36,10 @@ Diagrams: use `lit-diagram-drawer`.
 ## #contract.procedure
 
 1. Use `references/production.md` for direction, finite inventories, defaults, and material choices; explicit user direction wins.
-2. Evolve `litfamily.design-contract/v1beta2` with the build; validate before acceptance. Implement actions, states, accessibility, and responsive behavior. Inspect the running surface; `references/production.md` gives the full procedure and evidence boundaries.
+2. A new page or screen first asks the user to pick the house style with OpenCode's `question` tool (two to four from `references/house-styles.md`, the family default first as `(Recommended)`) unless the request names one or brand tokens or says "you choose"; a non-interactive run takes the default and says so in one line. Then it locks its look with `scripts/design-lock.mjs init` (`references/house-styles.md`): one house style, layout family and signature moment, rich density unless the request says minimal or calm; build only from the generated kit. Brand tokens win.
+3. Evolve `litfamily.design-contract/v1beta2` with the build; validate before acceptance. Implement actions, states, accessibility, and responsive behavior. Inspect the running surface; `references/production.md` gives the full procedure and evidence boundaries.
 
-Choose `build` by default, `polish` for value-only fixes, `audit` for read-only findings, or `harden` for cue-gated state stress. Read `references/craft-floor.md` and `references/slop-register.md`; run `node scripts/probe.mjs --path <entry.html> --out <evidence-dir>` against the finished page through the installed browser path, even when UI work is one slice of a larger loop. The command must attempt the full RS matrix; --help is not a page probe, and an ad hoc screenshot cannot replace its result. A missing browser or exit 2 is BLOCKED, not PASS. Fix remaining measured or derived HIGH findings before claiming done. For competing directions left unresolved, ask before choosing. Keep the fixed review table and explicit `Not verified` list.
+Choose `build` by default, `polish` for value-only fixes, `audit` for read-only findings, or `harden` for cue-gated state stress. Read `references/craft-floor.md` and `references/slop-register.md`; run `node scripts/probe.mjs --path <entry.html> --out <evidence-dir>` against the finished page through the installed browser path, even when UI work is one slice of a larger loop. The command must attempt the full RS matrix; --help is not a page probe, and an ad hoc screenshot cannot replace its result. A missing browser or exit 2 is BLOCKED, not PASS. A lock adds DS-001..008 and LOOK-1..6 to the probe. Fix remaining measured or derived HIGH findings before claiming done. For competing directions left unresolved, ask before choosing. Keep the fixed review table and explicit `Not verified` list.
 
 For motion, read `references/motion-guide.md`; Phase 3 capture examples are specified in `references/complete-contract.md`.