@dezycro-ai/agent-plugin 2.0.0

package/dist/hooks/lib/router.js

@@ -0,0 +1,717 @@
+/**
+ * router.ts — dispatches hook invocations to the right handler.
+ *
+ * The companion-runner shim parses argv and stdin payloads into a
+ * RouterInvocation and calls dispatch(). Per-handler boundaries try/catch
+ * via the runner entry point: any exception inside this module is logged
+ * by the runner and converts to silent exit so a hook never breaks a
+ * user session.
+ */
+'use strict';
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRIVIAL_TURN_CHAR_DEFAULT_EXPORT = exports._transcriptCharsSinceLastStop = exports._readActiveFeatureId = exports._handleSessionStart = exports._handleWorkbookMutation = exports._handleUserPromptSubmit = exports._handleStop = exports._handleUpdateTaskGate = exports._handlePostEdit = exports._extractEditedPaths = exports.QUALITY_GATE_REASON_PREFIX = void 0;
+exports.dispatch = dispatch;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config = __importStar(require("./config"));
+const state = __importStar(require("./state"));
+const logging = __importStar(require("./logging"));
+const verify = __importStar(require("./verify"));
+const controllerMatch = __importStar(require("./controller-match"));
+const authoring = __importStar(require("./authoring"));
+const qualityGate = __importStar(require("./quality-gate"));
+const hashing = __importStar(require("./hashing"));
+const workbook = __importStar(require("./workbook"));
+const undo = __importStar(require("./undo"));
+const coverage = __importStar(require("./coverage"));
+const DONE_STATUSES = new Set(['DONE', 'PUSHED']);
+const WRAP_PHRASES = [
+    '/dezycro:sync',
+    'log what we did',
+    'log this',
+    'save progress',
+    'save what we did',
+    'wrap up',
+    "we're done",
+    'we are done',
+    'end of session',
+    'sweep the workbook',
+];
+function detectWrapPhrase(userMessage) {
+    if (typeof userMessage !== 'string')
+        return null;
+    const m = userMessage.toLowerCase().trim();
+    if (!m)
+        return null;
+    for (const p of WRAP_PHRASES) {
+        if (m.includes(p))
+            return p;
+    }
+    return null;
+}
+exports.QUALITY_GATE_REASON_PREFIX = 'TRD quality gate (deterministic layer) blocked APPROVED transition: ';
+async function dispatch(invocation) {
+    const { event, route, payload, flags } = invocation;
+    if (event === 'state') {
+        return handleStateSubcommand(flags || {});
+    }
+    if (event === 'authoring-state') {
+        return handleAuthoringState(flags || {});
+    }
+    if (event === 'pre-tool-use' && route === 'update_task') {
+        return handleUpdateTaskGate(payload || {});
+    }
+    if (event === 'pre-tool-use' && route === 'change_document_status') {
+        return handleChangeDocumentStatus(payload || {});
+    }
+    if (event === 'post-tool-use' && route === 'edit') {
+        return handlePostEdit(payload || {});
+    }
+    if (event === 'post-tool-use' && route === 'workbook_mutation') {
+        return handleWorkbookMutation(payload || {});
+    }
+    if (event === 'session-start') {
+        return handleSessionStart(payload || {});
+    }
+    if (event === 'user-prompt-submit') {
+        return handleUserPromptSubmit(payload || {});
+    }
+    if (event === 'stop') {
+        return handleStop(payload || {});
+    }
+    return 0;
+}
+/* ─── Pillar 1 — pre-DONE verify gate (TRD §5.1) ─────────────────────────── */
+function handleUpdateTaskGate(payload) {
+    const repoRoot = config.findRepoRoot(process.cwd());
+    if (!repoRoot) {
+        process.stdout.write('{}');
+        return 0;
+    }
+    const toolInput = (payload && payload.tool_input) || {};
+    const status = String(toolInput.status || '').toUpperCase();
+    if (!DONE_STATUSES.has(status)) {
+        process.stdout.write('{}');
+        return 0;
+    }
+    const pathRefsRaw = toolInput.pathRefs;
+    const pathRefs = Array.isArray(pathRefsRaw) ? pathRefsRaw.filter(Boolean) : [];
+    if (pathRefs.length === 0) {
+        process.stdout.write('{}');
+        return 0;
+    }
+    const cfg = safeLoadConfig(repoRoot);
+    const av = (cfg && cfg.companion && cfg.companion.autoVerify) || {};
+    if (av.preTaskDone === false) {
+        process.stdout.write('{}');
+        return 0;
+    }
+    const passed = verify.hasRecentPassingVerify({ repoRoot, paths: pathRefs });
+    if (passed) {
+        logging.info(repoRoot, 'pre_done_gate_pass', { status, pathRefs });
+        // Pillar 4 pre-PUSH coverage nudge.
+        if (status === 'PUSHED') {
+            const nudge = buildPrePushCoverageNudge(repoRoot, cfg);
+            if (nudge) {
+                logging.info(repoRoot, 'pre_push_coverage_nudge', { line: nudge });
+                const out = { systemMessage: nudge };
+                process.stdout.write(JSON.stringify(out));
+                return 0;
+            }
+        }
+        process.stdout.write('{}');
+        return 0;
+    }
+    state.incrementMetric(repoRoot, 'verifyAutoRuns');
+    state.incrementMetric(repoRoot, 'verifyAutoFailures');
+    logging.warn(repoRoot, 'pre_done_gate_block', { status, pathRefs });
+    const reason = verify.buildBlockReason({ paths: pathRefs, status }).reason;
+    const out = {
+        decision: 'block',
+        reason,
+        hookSpecificOutput: {
+            hookEventName: 'PreToolUse',
+            permissionDecision: 'deny',
+            permissionDecisionReason: reason,
+        },
+    };
+    process.stdout.write(JSON.stringify(out));
+    return 0;
+}
+function buildPrePushCoverageNudge(repoRoot, cfg) {
+    const cv = (cfg && cfg.companion && cfg.companion.coverageNudges) || {};
+    if (cv.enabled === false)
+        return null;
+    const snap = state.read(repoRoot).coverageSnapshot;
+    const line = coverage.formatOneLiner(snap);
+    if (!line)
+        return null;
+    return `[Companion] ${line} — verify passed, but consider checking these before push.`;
+}
+/* ─── Pillar 5 — TRD quality gate on change_document_status (TRD §5.5.3) ── */
+function handleChangeDocumentStatus(payload) {
+    const toolInput = (payload && payload.tool_input) || {};
+    const ti = toolInput;
+    const status = ti.status || ti.newStatus || null;
+    const docId = ti.docId || ti.documentId || ti.id || null;
+    if (status !== 'APPROVED') {
+        process.stdout.write('{}');
+        return 0;
+    }
+    const repoRoot = config.findRepoRoot(process.cwd());
+    if (!repoRoot) {
+        process.stdout.write('{}');
+        return 0;
+    }
+    const sidecar = authoring.readDraftSidecar(repoRoot);
+    if (!sidecar || (docId && sidecar.docId && sidecar.docId !== docId)) {
+        logging.warn(repoRoot, 'quality_gate_degraded_permit', {
+            reason: sidecar ? 'docId_mismatch' : 'sidecar_missing',
+            docId,
+            sidecarDocId: sidecar ? sidecar.docId : null,
+        });
+        process.stdout.write('{}');
+        return 0;
+    }
+    if (sidecar.docType !== 'TRD') {
+        process.stdout.write('{}');
+        return 0;
+    }
+    const result = qualityGate.deterministicTrdGate({
+        trdContent: sidecar.content,
+        prdContent: sidecar.prdContent || '',
+    });
+    if (result.passed) {
+        logging.info(repoRoot, 'quality_gate_deterministic_pass', { docId: sidecar.docId });
+        process.stdout.write('{}');
+        return 0;
+    }
+    state.incrementMetric(repoRoot, 'qualityGateFailures');
+    const summary = result.blockingIssues
+        .map((b) => `[${b.section}] ${b.issue}`)
+        .slice(0, 5)
+        .join(' | ');
+    const reason = `${exports.QUALITY_GATE_REASON_PREFIX}${summary || 'unspecified failure'}. Fix and try again.`;
+    logging.warn(repoRoot, 'quality_gate_blocked', { docId: sidecar.docId, issues: result.blockingIssues });
+    const out = {
+        decision: 'block',
+        reason,
+        hookSpecificOutput: {
+            hookEventName: 'PreToolUse',
+            permissionDecision: 'deny',
+            permissionDecisionReason: reason,
+        },
+    };
+    process.stdout.write(JSON.stringify(out));
+    return 0;
+}
+/* ─── Pillars 1+2 — post-edit pulse + controller-match (TRD §5.1+§5.2) ─── */
+function handlePostEdit(payload) {
+    const repoRoot = config.findRepoRoot(process.cwd());
+    if (!repoRoot)
+        return 0;
+    const toolInput = (payload && payload.tool_input) || {};
+    const editedPaths = extractEditedPaths(toolInput);
+    if (editedPaths.length === 0)
+        return 0;
+    const cfg = safeLoadConfig(repoRoot);
+    const av = (cfg && cfg.companion && cfg.companion.autoVerify) || {};
+    const globs = Array.isArray(av.controllerPaths) ? av.controllerPaths : [];
+    const pulseEnabled = av.postEditPulse && av.postEditPulse.enabled !== false;
+    const pulseThreshold = (av.postEditPulse && Number(av.postEditPulse.threshold)) || 5;
+    const matchedControllers = controllerMatch.selectControllers(editedPaths, globs);
+    const editedTs = new Date().toISOString();
+    const current = state.read(repoRoot);
+    const nextPulseCount = (current.pulseCount || 0) + 1;
+    const shouldNudge = pulseEnabled &&
+        nextPulseCount >= pulseThreshold &&
+        matchedControllers.length > 0;
+    if (matchedControllers.length === 0) {
+        state.patch(repoRoot, {
+            pulseCount: nextPulseCount,
+            lastEditTs: editedTs,
+        });
+    }
+    else {
+        for (let i = 0; i < matchedControllers.length; i += 1) {
+            const isLast = i === matchedControllers.length - 1;
+            const editPatch = {
+                pushControllerEdit: { path: matchedControllers[i], editedTs },
+            };
+            if (isLast) {
+                editPatch.needsSpecPublish = true;
+                editPatch.lastEditTs = editedTs;
+                editPatch.pulseCount = shouldNudge ? 0 : nextPulseCount;
+            }
+            state.patch(repoRoot, editPatch);
+        }
+    }
+    logging.info(repoRoot, 'post_edit', {
+        edited: editedPaths.length,
+        matchedControllers: matchedControllers.length,
+        pulseCount: shouldNudge ? 0 : nextPulseCount,
+        nudged: shouldNudge,
+    });
+    if (shouldNudge) {
+        const nudge = '[Companion] ' + nextPulseCount + ' edits since last verify and controller paths were touched ' +
+            '(' + matchedControllers.join(', ') + '). Consider running `/dezycro:verify` to catch regressions early.';
+        process.stdout.write(JSON.stringify({
+            hookSpecificOutput: {
+                hookEventName: 'PostToolUse',
+                additionalContext: nudge,
+            },
+        }));
+    }
+    return 0;
+}
+function extractEditedPaths(toolInput) {
+    if (!toolInput || typeof toolInput !== 'object')
+        return [];
+    const fp = toolInput.file_path;
+    if (typeof fp === 'string')
+        return [fp];
+    const p = toolInput.path;
+    if (typeof p === 'string')
+        return [p];
+    const edits = toolInput.edits;
+    if (Array.isArray(edits)) {
+        const seen = new Set();
+        for (const e of edits) {
+            if (e && typeof e.file_path === 'string') {
+                seen.add(e.file_path);
+            }
+        }
+        return Array.from(seen);
+    }
+    return [];
+}
+/* ─── Skill-facing subcommands (state / authoring-state) ─────────────────── */
+function handleStateSubcommand(flags) {
+    const repoRoot = config.findRepoRoot(process.cwd()) || process.cwd();
+    if (flags.get) {
+        const snap = state.read(repoRoot);
+        process.stdout.write(JSON.stringify(snap, null, 2));
+        return 0;
+    }
+    if (typeof flags.patch === 'string') {
+        let parsed;
+        try {
+            parsed = JSON.parse(flags.patch);
+        }
+        catch (err) {
+            const msg = err.message;
+            process.stdout.write(JSON.stringify({ ok: false, error: 'invalid JSON for --patch: ' + msg }));
+            return 1;
+        }
+        if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            process.stdout.write(JSON.stringify({ ok: false, error: '--patch must be a JSON object' }));
+            return 1;
+        }
+        const next = state.patch(repoRoot, parsed);
+        if (next === null) {
+            process.stdout.write(JSON.stringify({ ok: false, error: 'lock contention — state not patched' }));
+            return 1;
+        }
+        process.stdout.write(JSON.stringify({ ok: true }));
+        return 0;
+    }
+    process.stdout.write(JSON.stringify({
+        ok: false,
+        error: 'state requires one of --get or --patch=<json>',
+    }));
+    return 1;
+}
+function handleAuthoringState(flags) {
+    const repoRoot = config.findRepoRoot(process.cwd()) || process.cwd();
+    const action = flags.set || (flags.get ? 'get' : null);
+    if (action === 'enter') {
+        const docId = flags['doc-id'];
+        const docType = flags['doc-type'];
+        if (!docId || !docType) {
+            process.stdout.write(JSON.stringify({
+                ok: false,
+                error: '--doc-id and --doc-type are required for --set=enter',
+            }));
+            return 1;
+        }
+        try {
+            const transcript = authoring.enter(repoRoot, {
+                docId,
+                docType: docType,
+                featureId: flags['feature-id'] || null,
+                seed: flags.seed || null,
+            });
+            process.stdout.write(JSON.stringify({ ok: true, transcript }));
+            return 0;
+        }
+        catch (err) {
+            process.stdout.write(JSON.stringify({ ok: false, error: err.message }));
+            return 1;
+        }
+    }
+    if (action === 'exit') {
+        try {
+            authoring.exit(repoRoot);
+            process.stdout.write(JSON.stringify({ ok: true }));
+            return 0;
+        }
+        catch (err) {
+            process.stdout.write(JSON.stringify({ ok: false, error: err.message }));
+            return 1;
+        }
+    }
+    if (action === 'get') {
+        const snap = authoring.getState(repoRoot);
+        process.stdout.write(JSON.stringify({ ok: true, ...snap }));
+        return 0;
+    }
+    process.stdout.write(JSON.stringify({
+        ok: false,
+        error: 'authoring-state requires one of --set=enter, --set=exit, --get',
+    }));
+    return 1;
+}
+/* ─── Pillar 3 — Proactive Workbook Updates (TRD §5.3) ────────────────────── */
+const TRIVIAL_TURN_CHAR_DEFAULT = 600;
+function handleSessionStart(_payload) {
+    const repoRoot = config.findRepoRoot(process.cwd());
+    if (!repoRoot)
+        return 0;
+    state.patch(repoRoot, {
+        sessionAutoLogCount: 0,
+        turnAutoLogCount: 0,
+        currentTurnId: 0,
+        lastAutoWorkbookMutation: null,
+        coverageFetchPending: false,
+    });
+    logging.info(repoRoot, 'session_start', {});
+    return 0;
+}
+function handleUserPromptSubmit(payload) {
+    const repoRoot = config.findRepoRoot(process.cwd());
+    if (!repoRoot)
+        return 0;
+    const current = state.read(repoRoot);
+    const nextTurnId = (current.currentTurnId || 0) + 1;
+    state.patch(repoRoot, {
+        currentTurnId: nextTurnId,
+        turnAutoLogCount: 0,
+    });
+    const userMessage = String(payload?.prompt ?? payload?.user_message ?? payload?.message ?? '').trim();
+    const wrap = detectWrapPhrase(userMessage);
+    if (wrap) {
+        state.patch(repoRoot, { pendingWorkbookSweep: true, pendingWorkbookSweepReason: 'wrap_phrase:' + wrap });
+        logging.info(repoRoot, 'wrap_phrase_detected', { phrase: wrap });
+    }
+    if (userMessage && undo.isUndoMessage(userMessage)) {
+        const mut = current.lastAutoWorkbookMutation;
+        if (mut && undo.isInUndoWindow(mut, nextTurnId)) {
+            const directive = undo.buildReversalDirective(mut);
+            if (directive) {
+                state.incrementMetric(repoRoot, 'undoCount');
+                state.patch(repoRoot, { lastAutoWorkbookMutation: null });
+                logging.info(repoRoot, 'undo_directive', { tool: directive.tool, entityId: mut.entityId });
+                const reason = '[Dezycro Companion — undo] ' + directive.humanLine + '\n\n' +
+                    'Call ' + directive.tool + ' with arguments:\n' +
+                    JSON.stringify(directive.args, null, 2) + '\n\n' +
+                    'Then confirm the reversal in one short sentence.';
+                const out = {
+                    hookSpecificOutput: {
+                        hookEventName: 'UserPromptSubmit',
+                        additionalContext: reason,
+                    },
+                };
+                process.stdout.write(JSON.stringify(out));
+                return 0;
+            }
+        }
+    }
+    maybeSurfaceCoverage(repoRoot, current);
+    process.stdout.write('{}');
+    return 0;
+}
+function maybeSurfaceCoverage(repoRoot, current) {
+    const cfg = safeLoadConfig(repoRoot);
+    if (cfg?.companion?.coverageNudges?.enabled === false)
+        return;
+    const snap = current.coverageSnapshot;
+    if (!snap)
+        return;
+    if (snap.surfacedTs)
+        return;
+    const line = coverage.formatOneLiner(snap);
+    if (!line)
+        return;
+    state.patch(repoRoot, {
+        coverageSnapshot: { ...snap, surfacedTs: new Date().toISOString() },
+    });
+    logging.info(repoRoot, 'coverage_one_liner', { line });
+    const out = {
+        hookSpecificOutput: {
+            hookEventName: 'UserPromptSubmit',
+            additionalContext: '[Companion] ' + line,
+        },
+    };
+    process.stdout.write(JSON.stringify(out));
+}
+function handleStop(payload) {
+    const repoRoot = config.findRepoRoot(process.cwd());
+    if (!repoRoot)
+        return 0;
+    const cfg = safeLoadConfig(repoRoot);
+    const ws = cfg?.companion?.autoWorkbookUpdates || {};
+    if (cfg?.companion?.safeMode === true)
+        return silentExit();
+    if (ws.enabled === false)
+        return silentExit();
+    const cur = state.read(repoRoot);
+    const verifyAdvanced = Boolean(cur.lastVerifyCompletionTs &&
+        cur.lastVerifyCompletionTs !== cur.lastSeenVerifyCompletionTs);
+    const hasTrigger = Boolean(cur.pendingWorkbookSweep || verifyAdvanced);
+    if (!hasTrigger) {
+        logging.info(repoRoot, 'stop_skip', { reason: 'no_trigger' });
+        if (verifyAdvanced) {
+            state.patch(repoRoot, { lastSeenVerifyCompletionTs: cur.lastVerifyCompletionTs });
+        }
+        return maybeStopCoverageDelta(repoRoot, cur);
+    }
+    if (cur.authoringMode) {
+        logging.info(repoRoot, 'stop_skip', { reason: 'authoring_mode' });
+        state.patch(repoRoot, {
+            pendingWorkbookSweep: false,
+            pendingWorkbookSweepReason: null,
+            lastSeenVerifyCompletionTs: cur.lastVerifyCompletionTs || cur.lastSeenVerifyCompletionTs,
+        });
+        return maybeStopCoverageDelta(repoRoot, cur);
+    }
+    const maxTurn = Number(ws.maxAutoLogsPerTurn ?? 2);
+    const maxSession = Number(ws.maxAutoLogsPerSession ?? 10);
+    const perTurnSlotsLeft = Math.max(0, maxTurn - (cur.turnAutoLogCount || 0));
+    const perSessionSlotsLeft = Math.max(0, maxSession - (cur.sessionAutoLogCount || 0));
+    if (perTurnSlotsLeft === 0 || perSessionSlotsLeft === 0) {
+        logging.info(repoRoot, 'stop_skip', {
+            reason: 'caps_exhausted',
+            perTurnSlotsLeft, perSessionSlotsLeft,
+        });
+        state.patch(repoRoot, {
+            pendingWorkbookSweep: false,
+            pendingWorkbookSweepReason: null,
+            lastSeenVerifyCompletionTs: cur.lastVerifyCompletionTs || cur.lastSeenVerifyCompletionTs,
+        });
+        return maybeStopCoverageDelta(repoRoot, cur);
+    }
+    if (cur.suppressWorkbookUpdatesUntil && Date.now() < new Date(cur.suppressWorkbookUpdatesUntil).getTime()) {
+        logging.info(repoRoot, 'stop_skip', { reason: 'suppressed' });
+        state.patch(repoRoot, {
+            pendingWorkbookSweep: false,
+            pendingWorkbookSweepReason: null,
+            lastSeenVerifyCompletionTs: cur.lastVerifyCompletionTs || cur.lastSeenVerifyCompletionTs,
+        });
+        return maybeStopCoverageDelta(repoRoot, cur);
+    }
+    state.patch(repoRoot, {
+        pendingWorkbookSweep: false,
+        pendingWorkbookSweepReason: null,
+        lastSeenVerifyCompletionTs: cur.lastVerifyCompletionTs || cur.lastSeenVerifyCompletionTs,
+    });
+    const thresholds = config.resolveThresholds(cfg);
+    const recentHashes = [
+        ...(cur.recentDecisionHashes || []),
+        ...(cur.recentIssueHashes || []),
+        ...(cur.recentAssumptionHashes || []),
+    ];
+    const activeFeature = readActiveFeature(repoRoot);
+    let directive = workbook.buildSweepDirective({
+        thresholds,
+        perTurnSlotsLeft,
+        perSessionSlotsLeft,
+        recentHashes,
+        activeFeatureId: activeFeature.featureId,
+        activeFeatureName: activeFeature.featureName,
+    });
+    logging.info(repoRoot, 'stop_sweep_directive', {
+        perTurnSlotsLeft, perSessionSlotsLeft, recentHashCount: recentHashes.length,
+    });
+    const delta = computeCoverageDeltaForStop(repoRoot, cur);
+    if (delta)
+        directive += '\n\n' + delta;
+    const out = { decision: 'block', reason: directive };
+    process.stdout.write(JSON.stringify(out));
+    return 0;
+}
+function maybeStopCoverageDelta(repoRoot, cur) {
+    const delta = computeCoverageDeltaForStop(repoRoot, cur);
+    if (!delta)
+        return silentExit();
+    logging.info(repoRoot, 'stop_coverage_delta', { delta });
+    const out = { systemMessage: delta };
+    process.stdout.write(JSON.stringify(out));
+    return 0;
+}
+function computeCoverageDeltaForStop(repoRoot, cur) {
+    const lastVerify = cur.lastVerifyCompletionTs;
+    const snap = cur.coverageSnapshot;
+    if (!lastVerify || !snap)
+        return null;
+    const surfaced = snap.surfacedTs ? new Date(snap.surfacedTs).getTime() : 0;
+    const verifyTs = new Date(lastVerify).getTime();
+    if (verifyTs <= surfaced)
+        return null;
+    const line = coverage.formatDelta(snap.previous || null, snap);
+    if (!line)
+        return null;
+    state.patch(repoRoot, { coverageSnapshot: { ...snap, surfacedTs: new Date().toISOString() } });
+    return '[Companion] ' + line;
+}
+function silentExit() { process.stdout.write('{}'); return 0; }
+function transcriptCharsSinceLastStop(payload) {
+    try {
+        const tp = payload?.transcript_path;
+        if (!tp || typeof tp !== 'string' || !fs.existsSync(tp))
+            return null;
+        const raw = fs.readFileSync(tp, 'utf8');
+        const lines = raw.split('\n').filter(Boolean);
+        let chars = 0;
+        let foundPrev = false;
+        for (let i = lines.length - 1; i >= 0; i -= 1) {
+            let evt;
+            try {
+                evt = JSON.parse(lines[i]);
+            }
+            catch {
+                continue;
+            }
+            const role = evt?.message?.role ?? evt?.role;
+            if (role === 'assistant') {
+                const txt = JSON.stringify(evt.message?.content ?? evt.content ?? '');
+                chars += txt.length;
+            }
+            else if (role === 'user') {
+                if (foundPrev)
+                    break;
+                foundPrev = true;
+                const txt = JSON.stringify(evt.message?.content ?? evt.content ?? '');
+                chars += txt.length;
+            }
+            if (chars > 1000000)
+                break;
+        }
+        return chars;
+    }
+    catch {
+        return null;
+    }
+}
+function readActiveFeatureId(repoRoot) {
+    return readActiveFeature(repoRoot).featureId;
+}
+function readActiveFeature(repoRoot) {
+    try {
+        const raw = fs.readFileSync(path.join(repoRoot, '.dezycro', 'active-feature.json'), 'utf8');
+        const p = JSON.parse(raw);
+        return { featureId: p?.featureId || null, featureName: p?.featureName || null };
+    }
+    catch {
+        return { featureId: null, featureName: null };
+    }
+}
+function safeLoadConfig(repoRoot) {
+    try {
+        return config.load(repoRoot);
+    }
+    catch {
+        return JSON.parse(JSON.stringify(config.DEFAULT_CONFIG));
+    }
+}
+function handleWorkbookMutation(payload) {
+    const repoRoot = config.findRepoRoot(process.cwd());
+    if (!repoRoot)
+        return 0;
+    const toolName = payload?.tool_name || '';
+    const kind = workbook.entityKindForTool(toolName);
+    if (!kind)
+        return 0;
+    const toolInput = (payload?.tool_input || {});
+    const toolResponse = (payload?.tool_response || payload?.response || {});
+    const summary = String(toolInput.summary || toolInput.title || toolInput.description || toolInput.statement || '');
+    const linkedTaskId = toolInput.taskId || toolInput.linkedTaskId || null;
+    const hash = hashing.hashCandidate(kind, summary, linkedTaskId);
+    const respData = toolResponse.data;
+    const entityId = toolResponse.id ||
+        (respData ? respData.id : undefined) ||
+        toolInput.taskId ||
+        null;
+    const cur = state.read(repoRoot);
+    const turnAutoLogCount = (cur.turnAutoLogCount || 0) + 1;
+    const sessionAutoLogCount = (cur.sessionAutoLogCount || 0) + 1;
+    const patch = {
+        turnAutoLogCount,
+        sessionAutoLogCount,
+        lastAutoWorkbookMutation: {
+            tool: toolName.split('__').pop() || '',
+            entityId,
+            createdInTurnId: cur.currentTurnId || 0,
+            createdTs: new Date().toISOString(),
+            priorStatus: toolInput.priorStatus || null,
+        },
+    };
+    if (kind === 'decision')
+        patch.pushDecisionHash = hash;
+    if (kind === 'issue')
+        patch.pushIssueHash = hash;
+    if (kind === 'assumption')
+        patch.pushAssumptionHash = hash;
+    state.patch(repoRoot, patch);
+    const metricKey = kind === 'decision' ? 'autoDecisionLogs' :
+        kind === 'issue' ? 'autoIssueLogs' :
+            kind === 'assumption' ? 'autoAssumptionLogs' :
+                'autoTaskStatusLogs';
+    state.incrementMetric(repoRoot, metricKey);
+    logging.info(repoRoot, 'workbook_mutation', { kind, entityId, turnAutoLogCount, sessionAutoLogCount });
+    process.stdout.write('{}');
+    return 0;
+}
+// Exposed for tests:
+exports._extractEditedPaths = extractEditedPaths;
+exports._handlePostEdit = handlePostEdit;
+exports._handleUpdateTaskGate = handleUpdateTaskGate;
+exports._handleStop = handleStop;
+exports._handleUserPromptSubmit = handleUserPromptSubmit;
+exports._handleWorkbookMutation = handleWorkbookMutation;
+exports._handleSessionStart = handleSessionStart;
+exports._readActiveFeatureId = readActiveFeatureId;
+exports._transcriptCharsSinceLastStop = transcriptCharsSinceLastStop;
+exports.TRIVIAL_TURN_CHAR_DEFAULT_EXPORT = TRIVIAL_TURN_CHAR_DEFAULT;