@litfamily/litcodex 1.0.0

package/marketplace/plugins/litcodex/components/start-work-continuation/dist/cli.js

@@ -0,0 +1,345 @@
+#!/usr/bin/env node
+import { stdin as processStdin, stdout as processStdout } from "node:process";
+import { runStopHook, runUserPromptSubmitHook } from "./codex-hook.js";
+import { initializeWork, isBoundedLifecycleText, START_WORK_MAX_DISPLAY_BYTES, START_WORK_MAX_STDIN_BYTES, transitionWork, } from "./lifecycle-store.js";
+import { analyzePlanProgress } from "./plan-progress.js";
+import { PlanPublisherError, publishPlan } from "./plan-publisher.js";
+import { diagnoseLifecycle } from "./work-state-reader.js";
+const USAGE = "Usage: litcodex-start-work-continuation init | analyze-plan | publish-plan --cwd <path> --slug <slug> | hook <stop|user-prompt-submit> | transition <pause|cancel|complete> | doctor --cwd <path> --json\n";
+const command = process.argv[2];
+const subcommand = process.argv[3];
+const publishPlanArgs = command === "publish-plan" ? parsePublishPlanArgs(process.argv.slice(3)) : null;
+if (command === "init" && subcommand === undefined) {
+    await runInitCli();
+}
+else if (command === "analyze-plan" && subcommand === undefined) {
+    await runAnalyzePlanCli();
+}
+else if (publishPlanArgs !== null) {
+    await runPublishPlanCli(publishPlanArgs);
+}
+else if (command === "hook" && (subcommand === "stop" || subcommand === "user-prompt-submit")) {
+    await runHookCli(subcommand);
+}
+else if (command === "hook" && subcommand === "subagent-stop") {
+    process.exitCode = 0;
+}
+else if (command === "transition" && isCliTransitionAction(subcommand)) {
+    await runTransitionCli(subcommand);
+}
+else if (command === "doctor" &&
+    process.argv[3] === "--cwd" &&
+    process.argv[5] === "--json" &&
+    process.argv.length === 6) {
+    runDoctorCli(process.argv[4]);
+}
+else {
+    process.stderr.write(USAGE);
+    process.exitCode = 1;
+}
+async function runHookCli(kind) {
+    const raw = await readStdin();
+    if (raw === null || raw.trim().length === 0)
+        return;
+    const parsed = parseJson(raw);
+    if (parsed === undefined)
+        return;
+    const output = kind === "stop" ? runStopHook(parsed) : runUserPromptSubmitHook(parsed);
+    if (output.length > 0)
+        processStdout.write(output);
+}
+async function runTransitionCli(action) {
+    const raw = await readStdin();
+    if (raw === null)
+        return fail("INPUT_TOO_LARGE", "transition stdin exceeded its byte limit");
+    const parsed = parseJson(raw);
+    if (!isTransitionCliInput(parsed, action))
+        return fail("INPUT_INVALID", "transition stdin must match the strict JSON schema");
+    try {
+        const result = transitionWork(parsed.cwd, {
+            action,
+            expectedRevision: parsed.expected_revision,
+            sessionId: parsed.session_id,
+            transitionId: parsed.transition_id,
+            workId: parsed.work_id,
+            reasonCode: parsed.reason_code,
+            ...(parsed.boundary === undefined ? {} : { boundary: parsed.boundary }),
+            ...(parsed.grant === undefined ? {} : { grant: parsed.grant }),
+            ...(parsed.authority === undefined
+                ? {}
+                : {
+                    authority: {
+                        authorityId: parsed.authority.authority_id,
+                        allowedRoots: parsed.authority.allowed_roots,
+                        allowedActions: parsed.authority.allowed_actions,
+                        forbiddenActions: parsed.authority.forbidden_actions,
+                    },
+                }),
+        });
+        const work = result.state.works[result.event.workId];
+        if (work === undefined)
+            return fail("STATE_INVALID", "active work disappeared");
+        processStdout.write(`${JSON.stringify({ ok: true, changed: result.changed, revision: result.state.revision, status: work.status, kind: result.event.kind })}\n`);
+    }
+    catch (error) {
+        return fail("TRANSITION_FAILED", error instanceof Error ? error.message : "transition failed");
+    }
+}
+async function runInitCli() {
+    const raw = await readStdin();
+    if (raw === null)
+        return fail("INPUT_TOO_LARGE", "init stdin exceeded its byte limit");
+    const parsed = parseJson(raw);
+    if (!isInitCliInput(parsed))
+        return fail("INPUT_INVALID", "init stdin must match the strict JSON schema");
+    try {
+        const result = initializeWork(parsed.cwd, {
+            initId: parsed.init_id,
+            expectedRevision: parsed.expected_revision,
+            workId: parsed.work_id,
+            plan: parsed.plan,
+            planName: parsed.plan_name,
+            sessionId: parsed.session_id,
+            worktreePath: parsed.worktree_path,
+            authority: {
+                authorityId: parsed.authority.authority_id,
+                allowedRoots: parsed.authority.allowed_roots,
+                allowedActions: parsed.authority.allowed_actions,
+                forbiddenActions: parsed.authority.forbidden_actions,
+            },
+        });
+        const work = result.state.works[result.event.workId];
+        if (work === undefined)
+            return fail("STATE_INVALID", "initialized work disappeared");
+        processStdout.write(`${JSON.stringify({ ok: true, changed: result.changed, revision: result.state.revision, status: work.status, kind: result.event.kind })}\n`);
+    }
+    catch (error) {
+        return fail("INIT_FAILED", error instanceof Error ? error.message : "init failed");
+    }
+}
+async function runAnalyzePlanCli() {
+    const markdown = await readStdin();
+    if (markdown === null)
+        return fail("INPUT_TOO_LARGE", "plan stdin exceeded its byte limit");
+    const progress = analyzePlanProgress(markdown);
+    if (!progress.contractValid)
+        return fail("PLAN_EMPTY", "start-work plan requires real Todos and final verification checkbox rows");
+    processStdout.write(`${JSON.stringify({ ok: true, progress })}\n`);
+}
+async function runPublishPlanCli(args) {
+    const markdown = await readStdin();
+    if (markdown === null)
+        return fail("INPUT_TOO_LARGE", "plan stdin exceeded its byte limit");
+    try {
+        const result = publishPlan(args.cwd, args.slug, markdown);
+        processStdout.write(`${JSON.stringify({ ok: true, path: result.path, progress: result.progress })}\n`);
+    }
+    catch (error) {
+        if (error instanceof PlanPublisherError)
+            return fail(error.code, error.message);
+        return fail("PLAN_WRITE_FAILED", "atomic plan write failed");
+    }
+}
+function runDoctorCli(cwd) {
+    if (!isBoundedLifecycleText(cwd)) {
+        fail("INPUT_INVALID", "doctor cwd is invalid");
+        return;
+    }
+    const diagnostic = diagnoseLifecycle(cwd);
+    processStdout.write(`${JSON.stringify(diagnostic)}\n`);
+    if (!diagnostic.ok)
+        process.exitCode = 2;
+}
+function fail(code, message) {
+    process.stderr.write(`${JSON.stringify({ ok: false, error: { code, message } })}\n`);
+    process.exitCode = 2;
+}
+function isTransitionCliInput(value, action) {
+    if (!isRecord(value))
+        return false;
+    const allowed = new Set([
+        "cwd",
+        "session_id",
+        "expected_revision",
+        "transition_id",
+        "work_id",
+        "reason_code",
+        "boundary",
+        "grant",
+        "authority",
+    ]);
+    if (Object.keys(value).some((key) => !allowed.has(key)))
+        return false;
+    const basic = isBoundedLifecycleText(value["cwd"]) &&
+        isBoundedLifecycleText(value["session_id"]) &&
+        Number.isSafeInteger(value["expected_revision"]) &&
+        value["expected_revision"] >= 0 &&
+        isBoundedLifecycleText(value["transition_id"]) &&
+        isBoundedLifecycleText(value["work_id"]) &&
+        isReasonCode(value["reason_code"]);
+    if (!basic)
+        return false;
+    const boundary = value["boundary"] === undefined ? undefined : parseBoundary(value["boundary"]);
+    const grant = value["grant"] === undefined ? undefined : parseGrant(value["grant"]);
+    const authority = value["authority"] === undefined ? undefined : parseAuthority(value["authority"]);
+    if ((value["boundary"] !== undefined && boundary === undefined) ||
+        (value["grant"] !== undefined && grant === undefined)) {
+        return false;
+    }
+    if (value["authority"] !== undefined && authority === undefined)
+        return false;
+    if (action === "pause")
+        return boundary !== undefined && grant === undefined && isPauseReason(value["reason_code"]);
+    if (action === "resume")
+        return boundary !== undefined && grant !== undefined && value["reason_code"] === "explicit_user_resume";
+    return boundary === undefined && grant === undefined;
+}
+function isInitCliInput(value) {
+    if (!isRecord(value))
+        return false;
+    const allowed = new Set([
+        "cwd",
+        "init_id",
+        "expected_revision",
+        "work_id",
+        "plan",
+        "plan_name",
+        "session_id",
+        "worktree_path",
+        "authority",
+    ]);
+    if (Object.keys(value).some((key) => !allowed.has(key)) || !isRecord(value["authority"]))
+        return false;
+    const authority = value["authority"];
+    const authorityKeys = new Set(["authority_id", "allowed_roots", "allowed_actions", "forbidden_actions"]);
+    if (Object.keys(authority).some((key) => !authorityKeys.has(key)))
+        return false;
+    return (isBoundedLifecycleText(value["cwd"]) &&
+        isBoundedLifecycleText(value["init_id"]) &&
+        Number.isSafeInteger(value["expected_revision"]) &&
+        value["expected_revision"] >= 0 &&
+        isBoundedLifecycleText(value["work_id"]) &&
+        isBoundedLifecycleText(value["plan"]) &&
+        isBoundedLifecycleText(value["plan_name"], START_WORK_MAX_DISPLAY_BYTES) &&
+        isBoundedLifecycleText(value["session_id"]) &&
+        (value["worktree_path"] === null || isBoundedLifecycleText(value["worktree_path"])) &&
+        parseAuthority(authority) !== undefined);
+}
+function isCliTransitionAction(value) {
+    return value === "pause" || value === "cancel" || value === "complete";
+}
+function parsePublishPlanArgs(args) {
+    if (args.length !== 4 || args[0] !== "--cwd" || args[2] !== "--slug")
+        return null;
+    const cwd = args[1];
+    const slug = args[3];
+    return typeof cwd === "string" && cwd.length > 0 && typeof slug === "string" && slug.length > 0
+        ? { cwd, slug }
+        : null;
+}
+function parseJson(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        if (error instanceof SyntaxError)
+            return undefined;
+        throw error;
+    }
+}
+function readStdin() {
+    return new Promise((resolve) => {
+        const chunks = [];
+        let bytes = 0;
+        let oversized = false;
+        processStdin.on("data", (chunk) => {
+            const buffer = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+            bytes += buffer.byteLength;
+            if (bytes > START_WORK_MAX_STDIN_BYTES) {
+                oversized = true;
+                chunks.length = 0;
+                return;
+            }
+            if (!oversized)
+                chunks.push(buffer);
+        });
+        processStdin.once("error", () => resolve(oversized ? null : Buffer.concat(chunks).toString("utf8")));
+        processStdin.once("end", () => resolve(oversized ? null : Buffer.concat(chunks).toString("utf8")));
+    });
+}
+function isBoundedStringArray(value) {
+    return (Array.isArray(value) &&
+        value.length > 0 &&
+        value.length <= 64 &&
+        value.every((item) => isBoundedLifecycleText(item)));
+}
+function isReasonCode(value) {
+    return (value === "authorization_required" ||
+        value === "credential_required" ||
+        value === "host_capability_required" ||
+        value === "explicit_user_resume" ||
+        value === "user_cancelled" ||
+        value === "completed");
+}
+function parseAuthority(value) {
+    if (!isRecord(value))
+        return undefined;
+    const keys = new Set(["authority_id", "allowed_roots", "allowed_actions", "forbidden_actions"]);
+    if (Object.keys(value).some((key) => !keys.has(key)))
+        return undefined;
+    return isBoundedLifecycleText(value["authority_id"]) &&
+        isBoundedStringArray(value["allowed_roots"]) &&
+        isBoundedStringArray(value["allowed_actions"]) &&
+        isBoundedStringArray(value["forbidden_actions"])
+        ? {
+            authority_id: value["authority_id"],
+            allowed_roots: value["allowed_roots"],
+            allowed_actions: value["allowed_actions"],
+            forbidden_actions: value["forbidden_actions"],
+        }
+        : undefined;
+}
+function parseBoundary(value) {
+    if (!isRecord(value))
+        return undefined;
+    const keys = new Set(["boundary_id", "authority_id", "action", "root"]);
+    if (Object.keys(value).some((key) => !keys.has(key)))
+        return undefined;
+    return isBoundedLifecycleText(value["boundary_id"]) &&
+        isBoundedLifecycleText(value["authority_id"]) &&
+        isBoundedLifecycleText(value["action"]) &&
+        isBoundedLifecycleText(value["root"])
+        ? {
+            boundary_id: value["boundary_id"],
+            authority_id: value["authority_id"],
+            action: value["action"],
+            root: value["root"],
+        }
+        : undefined;
+}
+function parseGrant(value) {
+    if (!isRecord(value))
+        return undefined;
+    const keys = new Set(["grant_id", "authority_id", "boundary_id", "action", "root"]);
+    if (Object.keys(value).some((key) => !keys.has(key)))
+        return undefined;
+    return isBoundedLifecycleText(value["grant_id"]) &&
+        isBoundedLifecycleText(value["authority_id"]) &&
+        isBoundedLifecycleText(value["boundary_id"]) &&
+        isBoundedLifecycleText(value["action"]) &&
+        isBoundedLifecycleText(value["root"])
+        ? {
+            grant_id: value["grant_id"],
+            authority_id: value["authority_id"],
+            boundary_id: value["boundary_id"],
+            action: value["action"],
+            root: value["root"],
+        }
+        : undefined;
+}
+function isPauseReason(value) {
+    return value === "authorization_required" || value === "credential_required" || value === "host_capability_required";
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/marketplace/plugins/litcodex/components/start-work-continuation/dist/codex-hook.d.ts

@@ -0,0 +1,12 @@
+import type { StoreOptions } from "./lifecycle-store.js";
+import type { ReadonlyFileSystem } from "./types.js";
+export declare function runStopHook(input: unknown, _legacyFs?: ReadonlyFileSystem): string;
+export declare function runUserPromptSubmitHook(input: unknown, options?: StoreOptions): string;
+interface StartWorkRoute {
+    readonly selector: string | null;
+    readonly resumeBoundaryId: string | null;
+    readonly grantId: string | null;
+    readonly worktreePath: string | null;
+}
+export declare function parseExplicitStartWorkPrompt(prompt: string): StartWorkRoute | null;
+export {};

package/marketplace/plugins/litcodex/components/start-work-continuation/dist/codex-hook.js

@@ -0,0 +1,292 @@
+import { createHash } from "node:crypto";
+import { closeSync, constants, fstatSync, openSync, readSync, realpathSync } from "node:fs";
+import { basename, isAbsolute } from "node:path";
+import { START_WORK_CONTINUATION_DIRECTIVE } from "./directive.js";
+import { advanceStopLease, inspectLifecycleState, reconcileLifecycleState, selectWorkForSession, transitionWork, } from "./lifecycle-store.js";
+import { readContinuationState } from "./work-state-reader.js";
+const MAX_TRANSCRIPT_BYTES = 2_000_000;
+const MAX_INPUT_STRING = 100_000;
+const TRUSTED_CONTEXT_ERROR_CODES = new Set(["context_length_exceeded", "context_too_large"]);
+const O_NOFOLLOW = typeof constants.O_NOFOLLOW === "number" ? constants.O_NOFOLLOW : 0;
+export function runStopHook(input, _legacyFs) {
+    if (!isStopInput(input))
+        return "";
+    if (input.stop_hook_active)
+        return "";
+    const transcript = inspectTranscript(input.transcript_path);
+    if (transcript !== "clear")
+        return "";
+    const continuation = readContinuationState(input.cwd, input.session_id);
+    if (continuation === null)
+        return "";
+    try {
+        const lease = advanceStopLease(input.cwd, {
+            sessionId: input.session_id,
+            turnId: input.turn_id,
+            progressToken: continuation.progressToken,
+            workId: continuation.workId,
+            expectedRevision: continuation.revision,
+        });
+        if (lease.outcome === "silent")
+            return "";
+        return block(renderDirective({ ...continuation, revision: lease.state.revision }, input.session_id));
+    }
+    catch (error) {
+        if (error instanceof Error)
+            return "";
+        throw error;
+    }
+}
+export function runUserPromptSubmitHook(input, options = {}) {
+    if (!isUserPromptSubmitInput(input))
+        return "";
+    const route = parseExplicitStartWorkPrompt(input.prompt);
+    if (route === null)
+        return "";
+    try {
+        reconcileLifecycleState(input.cwd, options);
+        const inspected = inspectLifecycleState(input.cwd);
+        if (!inspected.ok || inspected.state.active_work_id === null)
+            return "";
+        if (route.resumeBoundaryId === null || route.grantId === null)
+            return "";
+        const transitionId = `prompt-resume:${digest([inspected.state.active_work_id, route.resumeBoundaryId, route.grantId, input.session_id, input.turn_id].join("\0"))}`;
+        const paused = selectWorkForSession(inspected.state, input.session_id, ["paused"]);
+        const selected = paused ??
+            matchingResumeReplay(inspected.state.works[inspected.state.active_work_id], input.session_id, transitionId);
+        if (selected === null ||
+            !selectorMatches(route.selector, selected) ||
+            !worktreeMatches(route.worktreePath, selected)) {
+            return "";
+        }
+        const pending = selected.pending_boundary ??
+            (selected.last_transition?.kind === "start_work_resumed" ? selected.last_transition.boundary : undefined);
+        if (pending === undefined || pending.boundary_id !== route.resumeBoundaryId)
+            return "";
+        const grant = {
+            grant_id: route.grantId,
+            authority_id: pending.authority_id,
+            boundary_id: pending.boundary_id,
+            action: pending.action,
+            root: pending.root,
+        };
+        transitionWork(input.cwd, {
+            action: "resume",
+            expectedRevision: inspected.state.revision,
+            sessionId: input.session_id,
+            transitionId,
+            workId: selected.work_id,
+            reasonCode: "explicit_user_resume",
+            turnId: input.turn_id,
+            boundary: pending,
+            grant,
+        }, options);
+    }
+    catch (error) {
+        if (!(error instanceof Error))
+            throw error;
+    }
+    // Codex accepts a zero-byte successful UserPromptSubmit hook. The lit-loop handler owns the
+    // additionalContext directive for this same prompt; this lifecycle handler must not steal it.
+    return "";
+}
+function block(reason) {
+    return JSON.stringify({ decision: "block", reason });
+}
+function renderDirective(state, sessionId) {
+    const context = {
+        workId: state.workId,
+        revision: state.revision,
+        planName: state.planName,
+        planPath: state.planPath,
+        workStatePath: state.workStatePath,
+        remainingCount: state.checklist.remaining,
+        totalCount: state.checklist.total,
+        nextTaskLabel: state.checklist.nextTaskLabel,
+        worktreePath: state.worktreePath,
+        authority: state.authority,
+        authorityGrants: state.authorityGrants,
+        pendingBoundary: state.pendingBoundary,
+        ledgerPath: state.ledgerPath,
+        sessionId: `codex:${sessionId}`,
+    };
+    return START_WORK_CONTINUATION_DIRECTIVE.replace("{{START_WORK_CONTEXT_JSON}}", safeJson(context));
+}
+function safeJson(value) {
+    return JSON.stringify(value).replace(/[<>&`\u2028\u2029]/g, (character) => {
+        const code = character.codePointAt(0);
+        return code === undefined ? "" : `\\u${code.toString(16).padStart(4, "0")}`;
+    });
+}
+function inspectTranscript(transcriptPath) {
+    if (transcriptPath === null || transcriptPath.length === 0)
+        return "clear";
+    if (O_NOFOLLOW === 0)
+        return "invalid";
+    let fd;
+    try {
+        fd = openSync(transcriptPath, constants.O_RDONLY | O_NOFOLLOW);
+        const stat = fstatSync(fd);
+        if (!stat.isFile() || stat.size > MAX_TRANSCRIPT_BYTES)
+            return "invalid";
+        const buffer = Buffer.alloc(stat.size);
+        let offset = 0;
+        while (offset < buffer.byteLength) {
+            const read = readSync(fd, buffer, offset, buffer.byteLength - offset, offset);
+            if (read === 0)
+                break;
+            offset += read;
+        }
+        if (offset !== stat.size)
+            return "invalid";
+        for (const line of buffer.toString("utf8").split(/\r?\n/)) {
+            if (line.length === 0)
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                return "invalid";
+            }
+            if (isTrustedHostContextError(parsed))
+                return "pressure";
+        }
+        return "clear";
+    }
+    catch (error) {
+        if (error instanceof Error)
+            return "invalid";
+        throw error;
+    }
+    finally {
+        if (fd !== undefined)
+            closeSync(fd);
+    }
+}
+function isTrustedHostContextError(value) {
+    if (!isRecord(value))
+        return false;
+    if (value["type"] === "error") {
+        const error = value["error"];
+        return isRecord(error) && TRUSTED_CONTEXT_ERROR_CODES.has(String(error["code"]));
+    }
+    if (value["type"] !== "message")
+        return false;
+    const payload = value["payload"];
+    if (!isRecord(payload))
+        return false;
+    const content = payload["content"];
+    if (!isRecord(content))
+        return false;
+    const error = content["error"];
+    return isRecord(error) && TRUSTED_CONTEXT_ERROR_CODES.has(String(error["code"]));
+}
+export function parseExplicitStartWorkPrompt(prompt) {
+    if (/[^\S ]/u.test(prompt) || prompt.includes("  "))
+        return null;
+    const match = prompt.match(/^(?:start-work|\$start-work|lit start work|\$litcodex:start-work)(?: (.+))?$/u);
+    if (match === null)
+        return null;
+    let rest = match[1] ?? "";
+    let worktreePath = null;
+    const worktreeMatches = [...rest.matchAll(/(?:^| )--worktree /g)];
+    if (worktreeMatches.length > 1)
+        return null;
+    if (worktreeMatches.length === 1) {
+        const marker = worktreeMatches[0];
+        if (marker === undefined)
+            return null;
+        const index = marker.index;
+        if (index === undefined)
+            return null;
+        const prefixLength = marker[0].length;
+        worktreePath = rest.slice(index + prefixLength);
+        if (worktreePath.length === 0 || !isAbsolute(worktreePath) || / --\S/.test(worktreePath)) {
+            return null;
+        }
+        rest = rest.slice(0, index);
+        if (rest.endsWith(" "))
+            rest = rest.slice(0, -1);
+    }
+    const flags = rest.match(/^--resume ([^ ]+) --grant ([^ ]+)$/u) ?? rest.match(/^(.*?) --resume ([^ ]+) --grant ([^ ]+)$/u);
+    const selector = flags?.[1] === undefined ? rest : flags.length === 3 ? "" : (flags[1] ?? "");
+    const resumeBoundaryId = flags === null ? null : ((flags.length === 3 ? flags[1] : flags[2]) ?? null);
+    const grantId = flags === null ? null : ((flags.length === 3 ? flags[2] : flags[3]) ?? null);
+    if (selector.includes("--") || (resumeBoundaryId === null) !== (grantId === null))
+        return null;
+    return {
+        selector: selector.length === 0 ? null : selector,
+        resumeBoundaryId,
+        grantId,
+        worktreePath,
+    };
+}
+function matchingResumeReplay(work, sessionId, transitionId) {
+    if (work?.status !== "active" ||
+        !work.session_ids.includes(`codex:${sessionId}`) ||
+        work.last_transition?.transitionId !== transitionId ||
+        work.last_transition.kind !== "start_work_resumed")
+        return null;
+    return work;
+}
+function selectorMatches(selector, work) {
+    if (selector === null)
+        return true;
+    const file = basename(work.active_plan);
+    const stem = file.endsWith(".md") ? file.slice(0, -3) : file;
+    return selector === work.plan_name || selector === stem || selector === file || selector === work.active_plan;
+}
+function worktreeMatches(input, work) {
+    if (input === null)
+        return true;
+    if (work.worktree_path === null)
+        return false;
+    try {
+        return realpathSync(input) === work.worktree_path;
+    }
+    catch {
+        return false;
+    }
+}
+function isStopInput(value) {
+    return (isRecord(value) &&
+        isStopHookEventName(value["hook_event_name"]) &&
+        boundedString(value["session_id"]) &&
+        boundedString(value["turn_id"]) &&
+        (value["transcript_path"] === null || boundedPathString(value["transcript_path"])) &&
+        boundedString(value["cwd"]) &&
+        boundedString(value["model"]) &&
+        boundedString(value["permission_mode"]) &&
+        typeof value["stop_hook_active"] === "boolean" &&
+        optionalString(value["last_assistant_message"]));
+}
+function isUserPromptSubmitInput(value) {
+    return (isRecord(value) &&
+        value["hook_event_name"] === "UserPromptSubmit" &&
+        boundedString(value["session_id"]) &&
+        boundedString(value["turn_id"]) &&
+        boundedString(value["cwd"]) &&
+        boundedString(value["prompt"]) &&
+        (value["transcript_path"] === undefined ||
+            value["transcript_path"] === null ||
+            boundedPathString(value["transcript_path"])));
+}
+function isStopHookEventName(value) {
+    return value === "Stop";
+}
+function boundedString(value) {
+    return typeof value === "string" && value.length > 0 && value.length <= MAX_INPUT_STRING;
+}
+function boundedPathString(value) {
+    return typeof value === "string" && value.length <= MAX_INPUT_STRING;
+}
+function optionalString(value) {
+    return value === undefined || (typeof value === "string" && value.length <= MAX_INPUT_STRING);
+}
+function digest(value) {
+    return createHash("sha256").update(value).digest("hex").slice(0, 32);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/marketplace/plugins/litcodex/components/start-work-continuation/dist/directive.d.ts

@@ -0,0 +1 @@
+export declare const START_WORK_CONTINUATION_DIRECTIVE: string;

package/marketplace/plugins/litcodex/components/start-work-continuation/dist/directive.js

@@ -0,0 +1,2 @@
+import { readFileSync } from "node:fs";
+export const START_WORK_CONTINUATION_DIRECTIVE = readFileSync(new URL("../directive.md", import.meta.url), "utf8");

package/marketplace/plugins/litcodex/components/start-work-continuation/dist/index.d.ts

@@ -0,0 +1,11 @@
+export { runStopHook, runUserPromptSubmitHook } from "./codex-hook.js";
+export { START_WORK_CONTINUATION_DIRECTIVE } from "./directive.js";
+export type { AuthorityBoundary, AuthorityEnvelope, AuthorityGrant, CanonicalPlan, InitRequest, InitResult, LifecycleState, StoreOptions, TransitionRequest, TransitionResult, WorkLifecycleEvent, WorkLifecycleKind, WorkReasonCode, WorkStateEntry, WorkStatus, WorkTransitionAction, } from "./lifecycle-store.js";
+export { advanceStopLease, initializeWork, inspectLifecycleState, isBoundedLifecycleText, readLifecycleState, reconcileLifecycleState, resolveCanonicalPlan, START_WORK_MAX_HISTORY_EVENTS, selectWorkForSession, transitionWork, } from "./lifecycle-store.js";
+export type { PlanProgress } from "./plan-progress.js";
+export { analyzePlanProgress } from "./plan-progress.js";
+export type { PublishedPlan } from "./plan-publisher.js";
+export { PlanPublisherError, publishPlan } from "./plan-publisher.js";
+export type { ReadonlyFileSystem, StopHookEventName, StopHookOutput, StopInput, UserPromptSubmitInput, } from "./types.js";
+export type { ContinuationState, PlanChecklist } from "./work-state-reader.js";
+export { diagnoseLifecycle, parsePlanChecklist, readContinuationState } from "./work-state-reader.js";

package/marketplace/plugins/litcodex/components/start-work-continuation/dist/index.js

@@ -0,0 +1,6 @@
+export { runStopHook, runUserPromptSubmitHook } from "./codex-hook.js";
+export { START_WORK_CONTINUATION_DIRECTIVE } from "./directive.js";
+export { advanceStopLease, initializeWork, inspectLifecycleState, isBoundedLifecycleText, readLifecycleState, reconcileLifecycleState, resolveCanonicalPlan, START_WORK_MAX_HISTORY_EVENTS, selectWorkForSession, transitionWork, } from "./lifecycle-store.js";
+export { analyzePlanProgress } from "./plan-progress.js";
+export { PlanPublisherError, publishPlan } from "./plan-publisher.js";
+export { diagnoseLifecycle, parsePlanChecklist, readContinuationState } from "./work-state-reader.js";