@deftai/directive-core 0.89.0 → 0.90.0

package/dist/doctor/types.d.ts

@@ -75,6 +75,10 @@ export interface DoctorFlags {
     readonly network: boolean;
     readonly help: boolean;
     readonly projectRoot: string | null;
+    /** Replace divergent OpenClaw pin dirs during doctor --fix (#3001). */
+    readonly force: boolean;
+    /** Wire always-pins into main + every workspace-* seat (#3001). */
+    readonly openclawAllAgents: boolean;
     readonly unknown: readonly string[];
 }
 export interface ThrottleDecision {
@@ -161,5 +165,12 @@ export interface DoctorSeams {
         readonly distance: "current" | "behind-minor" | "behind-major";
         readonly stale: boolean;
     };
+    /**
+     * OpenClaw skill-pin seams (#3001). Injected so detect/fix stays offline +
+     * deterministic in tests (fake HOME / env / fs).
+     */
+    readonly openclawEnv?: NodeJS.ProcessEnv;
+    readonly openclawHomeDir?: () => string;
+    readonly openclawContentRootFor?: (frameworkRoot: string) => string;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/hooks/dispatcher.js

@@ -7,9 +7,10 @@ import { detectNoDeftDirective, NO_DEFT_DIRECTIVE_DISABLED_MESSAGE, NO_DEFT_DIRE
 import { classifyMcpTool, DEFAULT_RUNTIME_AUTHORITY_POLICY, evaluateRuntimeAuthorityDirectWrite, evaluateRuntimeAuthorityShellOp, listShellOps, loadRuntimeAuthorityFromProject, } from "../policy/runtime-authority.js";
 import { loadStoryWriteFenceFromPath, resolveWriteFence } from "../policy/write-fence.js";
 import { detectBranch } from "../session/git.js";
+import { emitSessionRitualBlockedProcessCost } from "../session/process-cost.js";
 import { markRitualStaleAfterCompact } from "../session/ritual-sentinel.js";
 import { runSessionStartHookWrite } from "../session/session-start-hook.js";
-import { inspectSessionRitual } from "../session/verify-session-ritual.js";
+import { formatRitualRecoveryInstruction, inspectSessionRitual, } from "../session/verify-session-ritual.js";
 import { hookMcpArgsText, hookShellCommand, hookToolName, hookWriteTargetPath, missingToolNameMessage, record, } from "./classify/index.js";
 import { isExploreSpawn, isReadOnlyHookContext } from "./readonly.js";
 import { inspectActiveScope } from "./scope.js";
@@ -452,13 +453,27 @@ function inspectMutationGates(input, toolName, seams, options) {
             ((root) => inspectSessionRitual(root, { tier: "gated", posture: "mutation" })))(projectRoot);
     }
     catch (cause) {
+        // #2994: best-effort local process-cost; never changes deny verdict.
+        emitSessionRitualBlockedProcessCost({
+            toolName,
+            code: "ritual-not-ready",
+            recoveryTier: "cold",
+            detail: `inspect threw: ${String(cause)}`,
+        }, { projectRoot });
         return deny(input, "ritual-not-ready", toolName, `Directive could not inspect the gated session ritual: ${String(cause)}. ` +
-            "Run `deft session:start`, then `deft verify:session-ritual -- --tier=gated`.");
+            formatRitualRecoveryInstruction("cold"));
     }
     if (ritual.code !== 0) {
-        return deny(input, "ritual-not-ready", toolName, `Directive denied ${toolName}: ${ritual.message} ` +
-            "Recovery: run `deft session:start`, then " +
-            "`deft verify:session-ritual -- --tier=gated`.");
+        // #2992: prefer re-arm recovery when age/compact stale; cold when bind invalid.
+        const recoveryTier = ritual.recoveryTier === "rearm" ? "rearm" : "cold";
+        // #2994: best-effort local process-cost; never changes deny verdict.
+        emitSessionRitualBlockedProcessCost({
+            toolName,
+            code: "ritual-not-ready",
+            recoveryTier,
+            detail: ritual.message,
+        }, { projectRoot });
+        return deny(input, "ritual-not-ready", toolName, `Directive denied ${toolName}: ${ritual.message} ${formatRitualRecoveryInstruction(recoveryTier)}`);
     }
     if (options.proposedLifecycleExempt) {
         const writeTarget = hookWriteTargetPath(input.payload);

package/dist/index.d.ts

@@ -53,6 +53,7 @@ export * as session from "./session/index.js";
 export * as slice from "./slice/index.js";
 export * as storyReady from "./story-ready/index.js";
 export * as swarm from "./swarm/index.js";
+export * as toolEvents from "./tool-events/index.js";
 export * as triage from "./triage/index.js";
 export * as userConfig from "./user-config/index.js";
 export * as validateContent from "./validate-content/index.js";

package/dist/index.js

@@ -54,6 +54,7 @@ export * as session from "./session/index.js";
 export * as slice from "./slice/index.js";
 export * as storyReady from "./story-ready/index.js";
 export * as swarm from "./swarm/index.js";
+export * as toolEvents from "./tool-events/index.js";
 export * as triage from "./triage/index.js";
 export * as userConfig from "./user-config/index.js";
 export * as validateContent from "./validate-content/index.js";

package/dist/lifecycle/events.js

@@ -6,11 +6,13 @@ import { contentRoot } from "../content-root.js";
 import { ATTRIBUTION_REQUIRED_PAYLOAD } from "../events/attribution-constants.js";
 import { containedWrite } from "../fs/contained-write.js";
 import { ProjectionContainmentError } from "../fs/projection-containment.js";
+import { PROCESS_COST_REQUIRED_PAYLOAD } from "../session/process-cost-constants.js";
 /** Default event log location (project-local). */
 export const DEFAULT_EVENT_LOG = join(".deft-cache", "events.jsonl");
 const BEHAVIORAL_CATEGORY = "behavioral";
 const REQUIRED_BEHAVIORAL_PAYLOAD = {
     ...ATTRIBUTION_REQUIRED_PAYLOAD,
+    ...PROCESS_COST_REQUIRED_PAYLOAD,
     "session:interrupted": ["session_id", "reason"],
     "session:resumed": ["session_id", "interrupted_id"],
     "plan:approved": ["plan_ref", "approver"],

package/dist/lifecycle/index.d.ts

@@ -2,4 +2,5 @@ export * from "./event.js";
 export * as eventDetect from "./event-detect.js";
 export * as events from "./events.js";
 export * as lifecycleHygiene from "./lifecycle-hygiene.js";
+export * from "./stats.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/lifecycle/index.js

@@ -2,4 +2,5 @@ export * from "./event.js";
 export * as eventDetect from "./event-detect.js";
 export * as events from "./events.js";
 export * as lifecycleHygiene from "./lifecycle-hygiene.js";
+export * from "./stats.js";
 //# sourceMappingURL=index.js.map

package/dist/lifecycle/stats.d.ts

@@ -0,0 +1,53 @@
+import { parseDurationMs } from "../triage/scope/duration.js";
+/** Lifecycle folders scanned for stats. */
+export declare const STATS_LIFECYCLE_FOLDERS: readonly ["proposed", "pending", "active", "completed", "cancelled"];
+export type StatsLifecycleFolder = (typeof STATS_LIFECYCLE_FOLDERS)[number];
+/** Count semantics for WWYSYDH / process forms (stable strings for --json). */
+export declare const LIFECYCLE_STATS_SEMANTICS: {
+    readonly promoted: string;
+    readonly activated: string;
+    readonly completed: string;
+    readonly cancelled_or_failed: string;
+    readonly still_active: "snapshot count of all xbriefs currently in active/ (not filtered by --since).";
+    readonly event_time: string;
+    readonly note: string;
+};
+export interface LifecycleFolderTotals {
+    readonly proposed: number;
+    readonly pending: number;
+    readonly active: number;
+    readonly completed: number;
+    readonly cancelled: number;
+}
+export interface LifecycleStats {
+    readonly since: string;
+    readonly since_ms: number;
+    readonly as_of: string;
+    readonly window_start: string;
+    readonly project_root: string;
+    readonly lifecycle_root: string;
+    readonly promoted: number;
+    readonly activated: number;
+    readonly completed: number;
+    readonly cancelled_or_failed: number;
+    readonly still_active: number;
+    readonly folder_totals: LifecycleFolderTotals;
+    readonly semantics: typeof LIFECYCLE_STATS_SEMANTICS;
+}
+export interface CollectLifecycleStatsOptions {
+    readonly projectRoot: string;
+    /** Window duration string, e.g. "7d", "24h", "1w". Default "7d". */
+    readonly since?: string;
+    /** Clock for window end (tests inject a fixed Date). */
+    readonly now?: Date;
+}
+/**
+ * Collect lifecycle folder stats for a project root.
+ * Offline / filesystem only.
+ */
+export declare function collectLifecycleStats(options: CollectLifecycleStatsOptions): LifecycleStats;
+/** Format human-readable lifecycle stats text. */
+export declare function formatLifecycleStatsText(stats: LifecycleStats): string;
+/** Re-export duration parse for CLI error messaging. */
+export { parseDurationMs };
+//# sourceMappingURL=stats.d.ts.map

package/dist/lifecycle/stats.js

@@ -0,0 +1,286 @@
+/**
+ * Local xBRIEF lifecycle folder stats for weekly process rollups (#2995).
+ *
+ * Filesystem-only inventory of `xbrief/{proposed,pending,active,completed,cancelled}/`.
+ * No network calls.
+ */
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { hasArtifactSuffix, LEGACY_ARTIFACT_DIR, MIGRATED_ARTIFACT_DIR, } from "../layout/resolve.js";
+import { parseDurationMs } from "../triage/scope/duration.js";
+/** Lifecycle folders scanned for stats. */
+export const STATS_LIFECYCLE_FOLDERS = [
+    "proposed",
+    "pending",
+    "active",
+    "completed",
+    "cancelled",
+];
+/** Count semantics for WWYSYDH / process forms (stable strings for --json). */
+export const LIFECYCLE_STATS_SEMANTICS = {
+    promoted: "xbriefs currently in pending/ whose event time falls inside the --since window " +
+        "(promoted and still pending; later-activated work is not double-counted here).",
+    activated: "xbriefs currently in active/ whose event time falls inside the --since window " +
+        "(activated and still active).",
+    completed: "xbriefs currently in completed/ with plan.status completed (or unset, treated as completed) " +
+        "whose event time falls inside the --since window.",
+    cancelled_or_failed: "xbriefs currently in cancelled/, or in completed/ with plan.status failed, " +
+        "whose event time falls inside the --since window.",
+    still_active: "snapshot count of all xbriefs currently in active/ (not filtered by --since).",
+    event_time: "event time = most recent of plan.metadata.completedAt, plan.updated, and xBRIEFInfo/vBRIEFInfo.updated; " +
+        "else file mtime. Window is [as_of - since, as_of] inclusive of as_of.",
+    note: "Counts are current-folder membership, not full transition history. A brief that was " +
+        "promoted then activated in the same week appears under activated (and still_active), not promoted.",
+};
+function parseIso(value) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        return null;
+    }
+    const text = value.trim().endsWith("Z") ? `${value.trim().slice(0, -1)}+00:00` : value.trim();
+    const parsed = new Date(text);
+    if (Number.isNaN(parsed.getTime())) {
+        return null;
+    }
+    return parsed;
+}
+function readJsonObject(path) {
+    try {
+        const raw = readFileSync(path, "utf8");
+        const data = JSON.parse(raw);
+        if (typeof data !== "object" || data === null || Array.isArray(data)) {
+            return null;
+        }
+        return data;
+    }
+    catch {
+        return null;
+    }
+}
+function planOf(data) {
+    const plan = data.plan;
+    if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
+        return null;
+    }
+    return plan;
+}
+function infoUpdated(data) {
+    for (const key of ["xBRIEFInfo", "vBRIEFInfo"]) {
+        const info = data[key];
+        if (typeof info === "object" && info !== null && !Array.isArray(info)) {
+            const stamp = parseIso(info.updated);
+            if (stamp !== null) {
+                return stamp;
+            }
+        }
+    }
+    return null;
+}
+function completedAt(plan) {
+    const metadata = plan.metadata;
+    if (typeof metadata !== "object" || metadata === null || Array.isArray(metadata)) {
+        return null;
+    }
+    return parseIso(metadata.completedAt);
+}
+/**
+ * Event time for window membership: most recent of completedAt / plan.updated /
+ * info.updated, else mtime. Preferring max (not completedAt-first) so a later
+ * cancel/restore transition is not stuck on a stale completion stamp.
+ */
+function eventTimeFor(data, plan, path) {
+    const candidates = [];
+    const completed = completedAt(plan);
+    if (completed !== null) {
+        candidates.push(completed);
+    }
+    const planUpdated = parseIso(plan.updated);
+    if (planUpdated !== null) {
+        candidates.push(planUpdated);
+    }
+    const info = infoUpdated(data);
+    if (info !== null) {
+        candidates.push(info);
+    }
+    if (candidates.length > 0) {
+        return new Date(Math.max(...candidates.map((d) => d.getTime())));
+    }
+    try {
+        return new Date(statSync(path).mtimeMs);
+    }
+    catch {
+        return null;
+    }
+}
+/** Stats root: xbrief/ if present, else legacy vbrief/ (read-only inventory), else canonical xbrief path. */
+function resolveStatsLifecycleRoot(projectRoot) {
+    const migrated = join(projectRoot, MIGRATED_ARTIFACT_DIR);
+    if (existsSync(migrated)) {
+        try {
+            if (statSync(migrated).isDirectory()) {
+                return migrated;
+            }
+        }
+        catch {
+            // fall through
+        }
+    }
+    const legacy = join(projectRoot, LEGACY_ARTIFACT_DIR);
+    if (existsSync(legacy)) {
+        try {
+            if (statSync(legacy).isDirectory()) {
+                return legacy;
+            }
+        }
+        catch {
+            // fall through
+        }
+    }
+    return migrated;
+}
+function statusOf(plan, folder) {
+    const raw = plan.status;
+    if (typeof raw === "string" && raw.trim().length > 0) {
+        return raw.trim();
+    }
+    if (folder === "completed") {
+        return "completed";
+    }
+    if (folder === "cancelled") {
+        return "cancelled";
+    }
+    if (folder === "pending") {
+        return "pending";
+    }
+    if (folder === "active") {
+        return "running";
+    }
+    return "proposed";
+}
+function inWindow(eventTime, windowStart, asOf) {
+    if (eventTime === null) {
+        return false;
+    }
+    const t = eventTime.getTime();
+    return t >= windowStart.getTime() && t <= asOf.getTime();
+}
+function emptyFolderTotals() {
+    return { proposed: 0, pending: 0, active: 0, completed: 0, cancelled: 0 };
+}
+function scanArtifacts(lifecycleRoot) {
+    const out = [];
+    for (const folder of STATS_LIFECYCLE_FOLDERS) {
+        const dir = join(lifecycleRoot, folder);
+        if (!existsSync(dir)) {
+            continue;
+        }
+        let names;
+        try {
+            names = readdirSync(dir)
+                .filter((name) => hasArtifactSuffix(name))
+                .sort();
+        }
+        catch {
+            continue;
+        }
+        for (const name of names) {
+            const path = join(dir, name);
+            const data = readJsonObject(path);
+            if (data === null) {
+                continue;
+            }
+            const plan = planOf(data);
+            if (plan === null) {
+                continue;
+            }
+            out.push({
+                folder,
+                status: statusOf(plan, folder),
+                eventTime: eventTimeFor(data, plan, path),
+            });
+        }
+    }
+    return out;
+}
+function utcIso(dt) {
+    return `${dt.toISOString().slice(0, 19)}Z`;
+}
+/**
+ * Collect lifecycle folder stats for a project root.
+ * Offline / filesystem only.
+ */
+export function collectLifecycleStats(options) {
+    const sinceRaw = (options.since ?? "7d").trim() || "7d";
+    const sinceMs = parseDurationMs(sinceRaw);
+    const asOf = options.now ?? new Date();
+    const windowStart = new Date(asOf.getTime() - sinceMs);
+    const projectRoot = resolve(options.projectRoot);
+    const lifecycleRoot = resolveStatsLifecycleRoot(projectRoot);
+    const folder_totals = emptyFolderTotals();
+    let promoted = 0;
+    let activated = 0;
+    let completed = 0;
+    let cancelled_or_failed = 0;
+    let still_active = 0;
+    const records = existsSync(lifecycleRoot) ? scanArtifacts(lifecycleRoot) : [];
+    for (const rec of records) {
+        folder_totals[rec.folder] += 1;
+        if (rec.folder === "active") {
+            still_active += 1;
+        }
+        const win = inWindow(rec.eventTime, windowStart, asOf);
+        if (!win) {
+            continue;
+        }
+        if (rec.folder === "pending") {
+            promoted += 1;
+        }
+        else if (rec.folder === "active") {
+            activated += 1;
+        }
+        else if (rec.folder === "cancelled") {
+            cancelled_or_failed += 1;
+        }
+        else if (rec.folder === "completed") {
+            if (rec.status === "failed") {
+                cancelled_or_failed += 1;
+            }
+            else if (rec.status === "completed") {
+                completed += 1;
+            }
+            // Inconsistent statuses under completed/ (e.g. stale "running") are
+            // counted in folder_totals only — not in window metrics.
+        }
+    }
+    return {
+        since: sinceRaw,
+        since_ms: sinceMs,
+        as_of: utcIso(asOf),
+        window_start: utcIso(windowStart),
+        project_root: projectRoot,
+        lifecycle_root: lifecycleRoot,
+        promoted,
+        activated,
+        completed,
+        cancelled_or_failed,
+        still_active,
+        folder_totals: { ...folder_totals },
+        semantics: LIFECYCLE_STATS_SEMANTICS,
+    };
+}
+/** Format human-readable lifecycle stats text. */
+export function formatLifecycleStatsText(stats) {
+    const lines = [
+        `lifecycle:stats (since ${stats.since}, as of ${stats.as_of})`,
+        `  window: ${stats.window_start} → ${stats.as_of}`,
+        `  promoted: ${stats.promoted}`,
+        `  activated: ${stats.activated}`,
+        `  completed: ${stats.completed}`,
+        `  cancelled_or_failed: ${stats.cancelled_or_failed}`,
+        `  still_active: ${stats.still_active}`,
+        `  folder_totals: proposed=${stats.folder_totals.proposed} pending=${stats.folder_totals.pending} active=${stats.folder_totals.active} completed=${stats.folder_totals.completed} cancelled=${stats.folder_totals.cancelled}`,
+    ];
+    return `${lines.join("\n")}\n`;
+}
+/** Re-export duration parse for CLI error messaging. */
+export { parseDurationMs };
+//# sourceMappingURL=stats.js.map

package/dist/release/spawn.js

@@ -24,6 +24,19 @@ export function spawnText(cmd, args, options = {}) {
     if (status === null) {
         if (result.signal !== null && result.signal !== undefined) {
             status = 128;
+            // Timeout kills leave stderr empty; surface timeout so e2e never reports
+            // "failed: " with a blank reason (#3004 / #1867).
+            if (stderr.trim().length === 0) {
+                if (result.error) {
+                    stderr = result.error.message;
+                }
+                else if (options.timeoutMs !== undefined) {
+                    stderr = `process terminated by signal ${result.signal} (timeout ${options.timeoutMs}ms)`;
+                }
+                else {
+                    stderr = `process terminated by signal ${result.signal}`;
+                }
+            }
         }
         else if (result.error) {
             status = 2;

package/dist/release-e2e/git-ops.d.ts

@@ -1,4 +1,11 @@
+import type { SpawnResult } from "../release/types.js";
 import type { E2ESeams } from "./types.js";
+/** Mirror push can exceed the generic release `runGit` 30s cap (#3004). Align with clone. */
+export declare const PUSH_MIRROR_TIMEOUT_MS = 300000;
+/** Prefer stderr; never leave a blank reason after "failed:" (#3004). */
+export declare function formatGitOpFailure(op: string, result: SpawnResult, options?: {
+    timeoutMs?: number;
+}): string;
 export declare function cloneRepoToTemp(projectRoot: string, targetDir: string, seams?: E2ESeams): [boolean, string];
 export declare function setOriginToTempRepo(cloneDir: string, owner: string, slug: string, seams?: E2ESeams): [boolean, string];
 export declare function pushMirror(cloneDir: string, seams?: E2ESeams): [boolean, string];

package/dist/release-e2e/git-ops.js

@@ -1,11 +1,22 @@
 import { runGit as releaseRunGit } from "../release/git.js";
 import { spawnText } from "../release/spawn.js";
+/** Mirror push can exceed the generic release `runGit` 30s cap (#3004). Align with clone. */
+export const PUSH_MIRROR_TIMEOUT_MS = 300_000;
 function defaultRunGit(projectRoot, args, env, seams = {}) {
     if (seams.runGit) {
         return seams.runGit(projectRoot, args, env);
     }
     return releaseRunGit(projectRoot, args, { spawnText: seams.spawnText ?? spawnText }, env);
 }
+/** Prefer stderr; never leave a blank reason after "failed:" (#3004). */
+export function formatGitOpFailure(op, result, options = {}) {
+    const stderr = result.stderr.trim();
+    if (stderr.length > 0) {
+        return `${op} failed: ${stderr}`;
+    }
+    const timeoutHint = options.timeoutMs !== undefined ? `; possible timeout after ${options.timeoutMs}ms` : "";
+    return `${op} failed: no stderr (exit ${result.status ?? "null"}${timeoutHint})`;
+}
 export function cloneRepoToTemp(projectRoot, targetDir, seams = {}) {
     const env = { ...process.env, DEFT_PROJECT_ROOT: targetDir };
     const spawn = seams.spawnText ?? spawnText;
@@ -27,9 +38,31 @@ export function setOriginToTempRepo(cloneDir, owner, slug, seams = {}) {
     return [true, `origin -> ${url}`];
 }
 export function pushMirror(cloneDir, seams = {}) {
-    const result = defaultRunGit(cloneDir, ["push", "origin", "refs/heads/*:refs/heads/*", "refs/tags/*:refs/tags/*"], undefined, seams);
+    // Do not use default release runGit (30s) — full heads+tags mirror of directive
+    // routinely exceeds that on first push to an empty temp repo (#3004).
+    const pushArgs = [
+        "push",
+        "origin",
+        "refs/heads/*:refs/heads/*",
+        "refs/tags/*:refs/tags/*",
+    ];
+    let result;
+    if (seams.runGit) {
+        result = seams.runGit(cloneDir, [...pushArgs], undefined);
+    }
+    else {
+        const spawn = seams.spawnText ?? spawnText;
+        result = spawn("git", ["-C", cloneDir, ...pushArgs], {
+            timeoutMs: PUSH_MIRROR_TIMEOUT_MS,
+        });
+    }
     if (result.status !== 0) {
-        return [false, `git push (heads+tags refspecs) failed: ${result.stderr.trim()}`];
+        return [
+            false,
+            formatGitOpFailure("git push (heads+tags refspecs)", result, {
+                timeoutMs: PUSH_MIRROR_TIMEOUT_MS,
+            }),
+        ];
     }
     return [true, "pushed heads + tags to temp origin"];
 }

package/dist/session/index.d.ts

@@ -1,8 +1,10 @@
 export * from "./git.js";
 export * from "./json.js";
 export * from "./posture.js";
+export * from "./process-cost.js";
 export * from "./resume-conditions.js";
 export * from "./ritual-sentinel.js";
+export * from "./session-ready.js";
 export * from "./session-start.js";
 export * from "./session-start-hook.js";
 export * from "./time.js";

package/dist/session/index.js

@@ -1,8 +1,10 @@
 export * from "./git.js";
 export * from "./json.js";
 export * from "./posture.js";
+export * from "./process-cost.js";
 export * from "./resume-conditions.js";
 export * from "./ritual-sentinel.js";
+export * from "./session-ready.js";
 export * from "./session-start.js";
 export * from "./session-start-hook.js";
 export * from "./time.js";

package/dist/session/process-cost-constants.d.ts

@@ -0,0 +1,9 @@
+/** Canonical process-cost event names for ceremony observability (#2994). */
+export declare const PROCESS_COST_EVENT_NAMES: {
+    readonly sessionStart: "session:start";
+    readonly sessionRitualBlocked: "session:ritual-blocked";
+};
+export type ProcessCostEventName = (typeof PROCESS_COST_EVENT_NAMES)[keyof typeof PROCESS_COST_EVENT_NAMES];
+/** Required payload keys per process-cost event (merged into lifecycle/events). */
+export declare const PROCESS_COST_REQUIRED_PAYLOAD: Readonly<Record<string, readonly string[]>>;
+//# sourceMappingURL=process-cost-constants.d.ts.map

package/dist/session/process-cost-constants.js

@@ -0,0 +1,11 @@
+/** Canonical process-cost event names for ceremony observability (#2994). */
+export const PROCESS_COST_EVENT_NAMES = {
+    sessionStart: "session:start",
+    sessionRitualBlocked: "session:ritual-blocked",
+};
+/** Required payload keys per process-cost event (merged into lifecycle/events). */
+export const PROCESS_COST_REQUIRED_PAYLOAD = {
+    [PROCESS_COST_EVENT_NAMES.sessionStart]: ["ceremony_tier", "duration_ms", "exit_code"],
+    [PROCESS_COST_EVENT_NAMES.sessionRitualBlocked]: ["tool_name", "code"],
+};
+//# sourceMappingURL=process-cost-constants.js.map

package/dist/session/process-cost.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Local process-cost ceremony events (#2994).
+ *
+ * Always-on, best-effort appends to `.deft-cache/events.jsonl`.
+ * Not gated on valueFeedback (distinct from #1709 attribution).
+ * No remote / Product Insights upload (#2603 not required).
+ *
+ * Types are declared locally (not imported from session-start) so this module
+ * does not form an import cycle with session-start call sites.
+ */
+import { type BehavioralEventRecord } from "../lifecycle/events.js";
+export { PROCESS_COST_EVENT_NAMES, PROCESS_COST_REQUIRED_PAYLOAD, type ProcessCostEventName, } from "./process-cost-constants.js";
+/** Ceremony tier labels mirror session-start cold|rearm (#2992 / #2994). */
+export type ProcessCostCeremonyTier = "cold" | "rearm";
+export interface ProcessCostStepTiming {
+    readonly name: string;
+    readonly duration_ms: number;
+    readonly skipped?: boolean;
+}
+export interface EmitProcessCostOptions {
+    readonly projectRoot: string;
+    /**
+     * Optional explicit log path for tests.
+     * When omitted, `emit` resolves via DEFT_EVENT_LOG then `.deft-cache/events.jsonl`
+     * (must not pre-resolve the default here or DEFT_EVENT_LOG is bypassed).
+     */
+    readonly logPath?: string | null;
+}
+export interface SessionStartProcessCostInput {
+    readonly ceremonyTier: ProcessCostCeremonyTier;
+    readonly durationMs: number;
+    readonly exitCode: number;
+    readonly ready?: boolean;
+    readonly optionalNetwork?: boolean;
+    readonly steps?: readonly ProcessCostStepTiming[];
+}
+export interface SessionRitualBlockedProcessCostInput {
+    readonly toolName: string;
+    readonly code?: string;
+    readonly recoveryTier?: "cold" | "rearm";
+    readonly detail?: string;
+}
+/**
+ * Emit `session:start` after cold/re-arm ceremony completes (or fails early).
+ * Returns null on any failure (telemetry must not interrupt session:start).
+ */
+export declare function emitSessionStartProcessCost(input: SessionStartProcessCostInput, options: EmitProcessCostOptions): BehavioralEventRecord | null;
+/**
+ * Emit `session:ritual-blocked` on PreToolUse ritual-not-ready deny.
+ * Returns null on any failure (telemetry must not change deny verdict).
+ */
+export declare function emitSessionRitualBlockedProcessCost(input: SessionRitualBlockedProcessCostInput, options: EmitProcessCostOptions): BehavioralEventRecord | null;
+//# sourceMappingURL=process-cost.d.ts.map