@deftai/directive-core 0.104.0 → 0.106.0

package/dist/session/process-cost.js

@@ -7,8 +7,13 @@
  *
  * Types are declared locally (not imported from session-start) so this module
  * does not form an import cycle with session-start call sites.
+ *
+ * #3508: composed readers live on `task value:show` (`value/readback.ts`).
+ * This module measures CLI process time, not agent-turn wall clock (#3500).
+ * ⊗ Do not use a printed CLI duration as #3286 Later graduation input.
  */
-import { emit } from "../lifecycle/events.js";
+import { resolve } from "node:path";
+import { DEFAULT_EVENT_LOG, emit, readEvents, } from "../lifecycle/events.js";
 import { PROCESS_COST_EVENT_NAMES } from "./process-cost-constants.js";
 export { PROCESS_COST_EVENT_NAMES, PROCESS_COST_REQUIRED_PAYLOAD, } from "./process-cost-constants.js";
 /**
@@ -79,4 +84,187 @@ export function emitSessionRitualBlockedProcessCost(input, options) {
         return null;
     }
 }
+function isRecordPayload(payload) {
+    return payload !== null && typeof payload === "object" && !Array.isArray(payload);
+}
+function parseDetectedAt(record) {
+    const raw = record.detected_at;
+    if (typeof raw !== "string" || raw.trim().length === 0) {
+        return null;
+    }
+    let text = raw.trim();
+    if (text.endsWith("Z")) {
+        text = `${text.slice(0, -1)}+00:00`;
+    }
+    const parsed = new Date(text);
+    return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+function payloadNumber(payload, key) {
+    const raw = payload[key];
+    return typeof raw === "number" && Number.isFinite(raw) ? raw : null;
+}
+function resolveProcessCostLogPath(projectRoot, logPath) {
+    if (logPath !== undefined && logPath !== null) {
+        return resolve(logPath);
+    }
+    return resolve(projectRoot, DEFAULT_EVENT_LOG);
+}
+function parseSteps(payload) {
+    const raw = payload?.steps;
+    if (!Array.isArray(raw)) {
+        return [];
+    }
+    const out = [];
+    for (const item of raw) {
+        if (item === null || typeof item !== "object" || Array.isArray(item)) {
+            continue;
+        }
+        const rec = item;
+        if (typeof rec.name !== "string" || typeof rec.duration_ms !== "number") {
+            continue;
+        }
+        if (!Number.isFinite(rec.duration_ms)) {
+            continue;
+        }
+        const step = {
+            name: rec.name,
+            duration_ms: rec.duration_ms,
+        };
+        if (rec.skipped === true) {
+            out.push({ ...step, skipped: true });
+        }
+        else {
+            out.push(step);
+        }
+    }
+    return out;
+}
+function lastSessionStartForTier(events, tier) {
+    for (let i = events.length - 1; i >= 0; i -= 1) {
+        const record = events[i];
+        if (record === undefined || record.event !== PROCESS_COST_EVENT_NAMES.sessionStart) {
+            continue;
+        }
+        const payload = isRecordPayload(record.payload) ? record.payload : null;
+        if (payload?.ceremony_tier === tier) {
+            return record;
+        }
+    }
+    return null;
+}
+function durationFrom(record) {
+    if (record === null || !isRecordPayload(record.payload)) {
+        return null;
+    }
+    return payloadNumber(record.payload, "duration_ms");
+}
+function formatWindowLabel(windowMs) {
+    const days = Math.round(windowMs / 86_400_000);
+    if (days >= 1 && days * 86_400_000 === windowMs) {
+        return `${days}d`;
+    }
+    const hours = Math.round(windowMs / 3_600_000);
+    if (hours >= 1 && hours * 3_600_000 === windowMs) {
+        return `${hours}h`;
+    }
+    return `${windowMs}ms`;
+}
+/**
+ * Roll up ceremony cost from `.deft-cache/events.jsonl` (#3508).
+ * Measures CLI process time, not agent-turn wall clock (#3500).
+ */
+export function computeCeremonyCostRollup(options) {
+    const windowMs = options.windowMs ?? 7 * 86_400_000;
+    const now = options.now ?? new Date();
+    const sinceMs = now.getTime() - windowMs;
+    const logPath = resolveProcessCostLogPath(options.projectRoot, options.logPath);
+    let records = [];
+    try {
+        records = readEvents(logPath).filter((record) => {
+            if (record.event !== PROCESS_COST_EVENT_NAMES.sessionStart &&
+                record.event !== PROCESS_COST_EVENT_NAMES.sessionRitualBlocked) {
+                return false;
+            }
+            const at = parseDetectedAt(record);
+            if (at === null) {
+                return false;
+            }
+            return at.getTime() >= sinceMs;
+        });
+    }
+    catch {
+        records = [];
+    }
+    const lastCold = lastSessionStartForTier(records, "cold");
+    const lastRearm = lastSessionStartForTier(records, "rearm");
+    const recoveryTierDistribution = {};
+    let blockedRitualCount = 0;
+    for (const record of records) {
+        if (record.event !== PROCESS_COST_EVENT_NAMES.sessionRitualBlocked) {
+            continue;
+        }
+        blockedRitualCount += 1;
+        const payload = isRecordPayload(record.payload) ? record.payload : null;
+        const rawTier = payload?.recovery_tier;
+        const tier = typeof rawTier === "string" && rawTier.trim().length > 0 ? rawTier.trim() : "unspecified";
+        recoveryTierDistribution[tier] = (recoveryTierDistribution[tier] ?? 0) + 1;
+    }
+    return {
+        kind: "cli_process_time",
+        windowLabel: options.windowLabel ?? formatWindowLabel(windowMs),
+        lastColdDurationMs: durationFrom(lastCold),
+        lastRearmDurationMs: durationFrom(lastRearm),
+        lastColdSteps: parseSteps(lastCold !== null && isRecordPayload(lastCold.payload) ? lastCold.payload : null),
+        lastRearmSteps: parseSteps(lastRearm !== null && isRecordPayload(lastRearm.payload) ? lastRearm.payload : null),
+        blockedRitualCount,
+        recoveryTierDistribution,
+    };
+}
+function formatMs(value) {
+    return value === null ? "none" : `${value}ms`;
+}
+function formatSteps(steps) {
+    if (steps.length === 0) {
+        return "none";
+    }
+    return steps
+        .map((step) => {
+        const skip = step.skipped === true ? " skipped" : "";
+        return `${step.name}=${step.duration_ms}ms${skip}`;
+    })
+        .join(", ");
+}
+function formatRecovery(distribution) {
+    const parts = Object.entries(distribution)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([tier, count]) => `${tier}=${count}`);
+    return parts.length === 0 ? "none" : parts.join(", ");
+}
+/**
+ * Human rollup for the composed `value:show` reader (#3508).
+ * CLI process time, not agent-turn wall clock (#3500).
+ */
+export function formatCeremonyCostReport(rollup) {
+    const lines = [
+        `[ceremony] CLI process time (not agent-turn wall clock; #3508 / #2994) ` +
+            `(${rollup.windowLabel}):`,
+        `  last cold: ${formatMs(rollup.lastColdDurationMs)}`,
+        `  last re-arm: ${formatMs(rollup.lastRearmDurationMs)}`,
+        `  steps (last cold ${PROCESS_COST_EVENT_NAMES.sessionStart}): ` +
+            formatSteps(rollup.lastColdSteps),
+        `  steps (last re-arm ${PROCESS_COST_EVENT_NAMES.sessionStart}): ` +
+            formatSteps(rollup.lastRearmSteps),
+        `  blocked-ritual (${PROCESS_COST_EVENT_NAMES.sessionRitualBlocked}): ` +
+            String(rollup.blockedRitualCount),
+        `  recovery-tier: ${formatRecovery(rollup.recoveryTierDistribution)}`,
+    ];
+    return `${lines.join("\n")}\n`;
+}
+/**
+ * Operator-visible mutation `session:start` line (#3508).
+ * CLI process time only. ⊗ not #3286 Later graduation input.
+ */
+export function formatSessionStartCeremonyCostLine(ceremonyTier, durationMs) {
+    return `[deft session] ceremony ${ceremonyTier} ${durationMs}ms`;
+}
 //# sourceMappingURL=process-cost.js.map

package/dist/session/product-state-hash.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Product-state hash for AC-pass bank reuse (#3387).
+ *
+ * Acceptance plus product file bytes. Lifecycle dirs (xbrief/vbrief/.deft)
+ * are excluded so scope:complete moves do not invalidate a green bank.
+ */
+import { type GitRunner } from "./git.js";
+export interface HashProductStateInput {
+    readonly projectRoot: string;
+    readonly plan: Record<string, unknown>;
+    /** Explicit product files (tests / callers). Relative to projectRoot. */
+    readonly productPaths?: readonly string[];
+    readonly runGit?: GitRunner;
+}
+export interface ProductStateHash {
+    readonly digest: string;
+    /** False when no product surface could be enumerated — refuse reuse. */
+    readonly complete: boolean;
+    readonly files: readonly string[];
+}
+/**
+ * Hash plan.acceptance plus product files. Missing/empty product surface
+ * is incomplete so callers fail closed to a full walk (#3387).
+ */
+export declare function hashProductState(input: HashProductStateInput): ProductStateHash;
+//# sourceMappingURL=product-state-hash.d.ts.map