@vortex-os/base 0.10.0 → 0.12.0

package/dist/index.d.ts

@@ -179,6 +179,17 @@ interface AutoRecordConfig {
      * the gap but the agent leaves it for you.
      */
     readonly backfill: boolean;
+    /**
+     * The failure ledger (`data/_failures/`) — the self-improvement loop's
+     * evidence store. With this on, the agent records noticed failures
+     * (append-only, one file per occurrence) and the session-start report
+     * surfaces recurring keys with their escalation-ladder stage (2nd occurrence
+     * → the covering rule's gate is mandatory; 3rd+ → propose a deterministic
+     * guard — always a proposal, never auto-installed). On by default; off → no
+     * recording ritual and no report section ( `vortex failure` still works when
+     * invoked explicitly).
+     */
+    readonly failures: boolean;
 }
 /**
  * One environment label plus the signal that selects it. Rules are evaluated
@@ -2709,6 +2720,78 @@ declare function collectCarryover(repoRoot: string, ignore?: (repoRelPosixPath:
     interrupted: string | null;
 } | null;
 
+/**
+ * `vortex guard` — deterministic write-time guards, wired as Claude Code hooks.
+ *
+ * `guard write` is a PreToolUse hook for the file-writing tools
+ * (Write / Edit / MultiEdit / NotebookEdit). It reads the hook payload JSON
+ * from stdin and DENIES the call when the NEW text contains a literal control
+ * character (anything below U+0020 except tab/LF/CR, or U+007F) — the
+ * documented repeat-failure class where escape notation was intended but the
+ * raw byte got written into source files.
+ *
+ * Why a hook and not (another) rule: the failure happens precisely when the
+ * model's active context is saturated with the offending bytes, i.e. when
+ * memory-based discipline is weakest. A deterministic check at the write
+ * boundary does not depend on recall. This is the "3rd occurrence → promote to
+ * a deterministic guard" rung of the failure-ledger ladder, shipped as a
+ * framework default because the class has zero legitimate uses in text writes
+ * (escape notation is always available).
+ *
+ * Contract (mirrors the statusline renderer's "never break the host"):
+ *  - only the NEW text is scanned (`content`, `new_string`, `edits[].new_string`,
+ *    `new_source`) — `old_string` is deliberately NOT scanned, so cleaning an
+ *    already-polluted file stays possible;
+ *  - a clean payload produces NO output (exit 0) — the normal permission flow
+ *    proceeds untouched;
+ *  - a malformed payload, an unexpected tool, or any internal error is
+ *    FAIL-OPEN: exit 0, no output, never a blocked write from a guard bug.
+ */
+/** The PreToolUse hook command `vortex init` wires (self-silencing like the session hooks). */
+declare const GUARD_WRITE_COMMAND = "npx --no-install vortex guard write || exit 0";
+/** Tool-name matcher for the guard's hook group. */
+declare const GUARD_WRITE_MATCHER = "Write|Edit|MultiEdit|NotebookEdit";
+/** A literal control character found in to-be-written text. */
+interface GuardFinding {
+    /** Which payload field carried it (e.g. `content`, `edits[2].new_string`). */
+    readonly field: string;
+    /** Character offset within that field. */
+    readonly index: number;
+    readonly codePoint: number;
+}
+/** First forbidden control character in `text`, or null. */
+declare function findControlChar(text: string): {
+    index: number;
+    codePoint: number;
+} | null;
+/**
+ * Scan a PreToolUse `tool_input` for forbidden control characters in every
+ * NEW-text field. Returns the first finding, or null when clean.
+ */
+declare function scanToolInput(toolInput: Record<string, unknown>): GuardFinding | null;
+/** Build the PreToolUse deny JSON for a finding. */
+declare function buildDenyDecision(finding: GuardFinding): string;
+/**
+ * Decide on a raw PreToolUse payload. Returns the hook's stdout JSON (a deny
+ * decision) when a forbidden character is found, or null to stay silent
+ * (allow / not applicable / out-of-scope tool / unparseable — fail-open by design).
+ */
+declare function guardWriteDecision(payloadText: string): string | null;
+/**
+ * CLI entry — `vortex guard write` (stdin: PreToolUse payload JSON).
+ * Always exits 0: a deny is expressed via the JSON decision on stdout, and
+ * everything else stays silent so the hook's `|| exit 0` wrapper never fires.
+ */
+declare function runGuardCli(argv: readonly string[], out: (s: string) => void, err: (s: string) => void): Promise<number>;
+/**
+ * Nearest VortEX instance root at or above `startDir` (marker:
+ * `.agent/vortex.json`), preferring an explicit `VORTEX_REPO_ROOT`, then the
+ * host-provided `CLAUDE_PROJECT_DIR` — each honored only when it actually IS
+ * an instance. Bounded walk; null when nothing matches (not an instance —
+ * the guard still denies, it just has no ledger to count into).
+ */
+declare function resolveInstanceRoot(startDir: string): string | null;
+
 /**
  * Hook wiring for `/vortex init`: make sure the instance's
  * `.claude/settings.json` registers the VortEX SessionStart / SessionEnd hooks,
@@ -2722,6 +2805,7 @@ declare function collectCarryover(repoRoot: string, ignore?: (repoRelPosixPath:
  */
 declare const SESSION_START_COMMAND = "npx --no-install vortex session-start || exit 0";
 declare const SESSION_END_COMMAND = "npx --no-install vortex session-end || exit 0";
+
 interface HookCommand {
     readonly type: "command";
     readonly command: string;
@@ -2745,7 +2829,7 @@ interface EnsureHooksResult {
      * migrated/de-duplicated in place (empty when nothing changed). Callers should
      * key "did we need to write?" off `alreadyWired`, not the name "added".
      */
-    readonly added: readonly ("SessionStart" | "SessionEnd")[];
+    readonly added: readonly string[];
     /** True when nothing changed — every VortEX hook was already present. */
     readonly alreadyWired: boolean;
 }
@@ -2758,8 +2842,16 @@ declare function parseSettings(text: string | null | undefined): ClaudeSettings;
  * Merge the VortEX hooks into an existing settings object WITHOUT mutating the
  * input. A hook event is left untouched if it already references our command
  * (idempotent); otherwise our group is appended alongside any existing groups.
+ *
+ * `opts.guard` additionally wires the PreToolUse control-byte guard
+ * (`vortex guard write`) for the file-writing tools. It is requested by
+ * `vortex init` (instance settings) but NOT by `vortex global-setup`: a
+ * machine-global deny hook would fire in every project on the machine, which
+ * is a stronger default than "the instance opted into VortEX conventions".
  */
-declare function ensureVortexHooks(existing: ClaudeSettings | null | undefined): EnsureHooksResult;
+declare function ensureVortexHooks(existing: ClaudeSettings | null | undefined, opts?: {
+    readonly guard?: boolean;
+}): EnsureHooksResult;
 /** Serialize settings the way Claude writes them (2-space, trailing newline). */
 declare function serializeSettings(settings: ClaudeSettings): string;
 
@@ -3263,6 +3355,24 @@ declare function renderSessionStartReport(report: SessionStartHookReport, extras
         readonly uncommitted: number;
         readonly interrupted: string | null;
     };
+    /**
+     * Failure-ledger recurrence warnings (`data/_failures/`, gated by
+     * `autoRecord.failures`): keys with 2+ open occurrences and their
+     * escalation-ladder stage — 2nd occurrence = the covering rule's gate is
+     * mandatory this session; 3rd+ = propose a deterministic guard (proposal
+     * only). Machine-counted so escalation never depends on anyone remembering.
+     */
+    readonly failures?: {
+        readonly warnings: readonly {
+            readonly key: string;
+            readonly count: number;
+            readonly stage: "recorded" | "gate" | "promote";
+            readonly rule: string | null;
+            readonly lastDate: string;
+        }[];
+        readonly totalOpen: number;
+        readonly omitted: number;
+    };
 }): string;
 
 /**
@@ -3334,6 +3444,278 @@ interface CatchUpOptions {
 }
 declare function catchUpSessions(ctx: ModuleContext, opts?: CatchUpOptions): Promise<CatchUpResult>;
 
+/**
+ * `vortex statusline` — a Claude Code statusLine renderer.
+ *
+ * Claude Code pipes a JSON snapshot of the session (model, context window,
+ * cost, rate limits, workspace) to the configured statusLine command on every
+ * refresh and renders whatever the command prints. This module turns that
+ * snapshot into a colored status bar:
+ *
+ *   full (default, 3 lines + a VortEX line inside an instance):
+ *     🧠 Fable 5 │ █ max │ █░░░░░░░░░ 12% · 120K/1M │ 🕐 22:25 │ 💰 $9.22
+ *     5h ██████░░ 75%(2h13m) │ 7d ███████░ 96%(0d8h) │ 📦 cache 98%
+ *     📁 my-project │ ⎇ main 2b0949d │ ⏱ 1h19m │ +78 -38 │ ⧉ 1
+ *     🌀 VortEX v0.11.0 │ last: 2026-06-10_0452-….md
+ *
+ *   lite (1 line):
+ *     📁 my-project │ ⎇ main │ 🧠 Fable 5 │ █ max │ ░░░░░░░░ 12% · 120K/1M │ 5h 75% · 7d 96% │ ⧉ 1 │ 🌀 v0.11.0 │ 🕐 22:25
+ *
+ * Design notes:
+ *  - Rendering is PURE (`renderStatusline(data, probes, mode)`) — every
+ *    environment lookup (git, process list, clock, VortEX instance files) is
+ *    collected separately in `collectStatuslineProbes`, so the composition is
+ *    unit-testable without a repo or a terminal.
+ *  - Reasoning effort is shown as one bar whose height + color encode the
+ *    level. Claude Code reports `ultracode` as plain `xhigh` (ultracode is
+ *    "xhigh + workflow orchestration"), so when the level reads `xhigh` we
+ *    additionally sniff the session transcript for the last `/effort` change
+ *    notice — a best-effort heuristic that degrades to showing `xhigh`.
+ *  - Every probe is wrapped: a statusline must NEVER throw or block the bar —
+ *    on any failure a segment silently falls back to a neutral value.
+ */
+
+/** The slice of Claude Code's statusLine input JSON this renderer consumes. */
+interface StatuslineData {
+    readonly modelName: string;
+    /** Reasoning effort level as reported (`effort.level`), or null. */
+    readonly effortLevel: string | null;
+    readonly transcriptPath: string | null;
+    /** Project directory (workspace.current_dir, falling back to cwd). */
+    readonly dir: string | null;
+    readonly contextWindowSize: number;
+    /** Context used, percent — kept as reported (may be fractional). */
+    readonly usedPercentage: number;
+    readonly cacheReadTokens: number;
+    readonly cacheCreationTokens: number;
+    readonly costUsd: number;
+    readonly durationMs: number;
+    readonly linesAdded: number;
+    readonly linesRemoved: number;
+    readonly fiveHourUsedPct: number;
+    readonly fiveHourResetsAt: number;
+    readonly sevenDayUsedPct: number;
+    readonly sevenDayResetsAt: number;
+}
+/** Environment lookups the renderer composes in — collected impurely, injected purely. */
+interface StatuslineProbes {
+    readonly gitBranch: string;
+    readonly gitHash: string;
+    readonly sessionCount: number;
+    /** Set when `dir` is a VortEX instance root; lastWorklog is the newest worklog file name. */
+    readonly vortex: {
+        readonly version: string | null;
+        readonly lastWorklog: string | null;
+    } | null;
+    /** Effort level after the ultracode transcript sniff (null → use data.effortLevel). */
+    readonly effortLevel: string | null;
+    readonly now: Date;
+}
+/**
+ * Make a dynamic string safe to put in a single-line ANSI bar: drop control
+ * chars (incl. ESC — no injected sequences/newlines), collapse whitespace, and
+ * truncate long values. The bar must render intact whatever a branch name,
+ * model name, or worklog filename contains.
+ */
+declare function safeSegment(s: string, max?: number): string;
+/** Parse Claude Code's statusLine stdin JSON into the fields the bar uses. Never throws on shape — only on non-JSON. */
+declare function parseStatuslineInput(text: string): StatuslineData;
+/** One-character effort meter: height + color encode the level (`█✦` for ultracode). */
+declare function effortMeter(level: string | null): {
+    meter: string;
+    color: string;
+} | null;
+/** `7` → `7`, `70_000` → `70K`, `1_200_000` → `1.2M` (token quantities). */
+declare function formatTokens(t: number): string;
+/** Window sizes render without a decimal: `200_000` → `200K`, `1_000_000` → `1M`. */
+declare function formatWindow(t: number): string;
+/** `█`-filled gauge, `width` cells, floor-scaled so 100% and only 100% fills it. */
+declare function makeBar(pct: number, width: number): string;
+/** Compose the status bar. Pure — see `collectStatuslineProbes` for the impure half. */
+declare function renderStatusline(d: StatuslineData, p: StatuslineProbes, mode?: "full" | "lite"): string;
+/**
+ * Claude Code reports `ultracode` as `xhigh`; the transcript keeps the last
+ * `/effort` change notice. Read the transcript tail and return the level named
+ * by the LAST such notice, or null. Best-effort by design — a format change
+ * simply degrades the display to `xhigh`.
+ */
+declare function sniffEffortFromTranscript(transcriptPath: string, maxBytes?: number): string | null;
+/** Collect every environment lookup the renderer needs for this input. */
+declare function collectStatuslineProbes(d: StatuslineData, now?: Date): StatuslineProbes;
+/**
+ * The statusLine command written by `install`.
+ *
+ * The host runs the statusLine command in the session's CURRENT working
+ * directory — which MOVES as the session `cd`s around (measured: the hook cwd
+ * followed the shell into a sibling repo). Anything cwd-relative (bare `npx`
+ * lookup, `./node_modules/...`) therefore silently resolves nothing the moment
+ * the session leaves the project, and the bar just vanishes. So:
+ *  - with a local install (`directRoot`): invoke the bin by ABSOLUTE path —
+ *    immune to cwd, and ~0.5s faster per refresh than npx (the other observed
+ *    disappearing-bar mode: npx latency under load) — with the npx lookup
+ *    chained as a fallback for when the repo has moved;
+ *  - global-only installs: the npx form alone (cwd-sensitive, but there is no
+ *    local path to pin).
+ * Always self-silencing (`|| exit 0`).
+ */
+declare function statuslineCommand(lite: boolean, directRoot?: string): string;
+interface StatuslineInstallResult {
+    readonly status: "installed" | "already-ours" | "kept-existing";
+    readonly settingsPath: string;
+    readonly command?: string;
+    /** Present when status is "kept-existing": the command we refused to overwrite. */
+    readonly existing?: string;
+}
+/**
+ * Merge `statusLine` into a settings object. NON-DESTRUCTIVE: an existing
+ * statusLine that is not ours is kept (the user owns their bar) unless `force`.
+ * Switching full↔lite of our own command counts as ours and is updated.
+ */
+declare function ensureStatusline(existing: ClaudeSettings, lite: boolean, force?: boolean, directRoot?: string): {
+    settings: ClaudeSettings;
+    status: StatuslineInstallResult["status"];
+    existing?: string;
+};
+/**
+ * Run the statusline CLI. `install` wires `.claude/settings.json` (at
+ * `repoRoot`); anything else renders the bar from stdin JSON. A render must
+ * never break the bar: bad/absent input prints nothing and exits 0.
+ */
+declare function runStatuslineCli(argv: readonly string[], repoRoot: string, out: (s: string) => void, err: (s: string) => void): Promise<number>;
+
+/**
+ * Failure ledger (`data/_failures/`) — the evidence store of the
+ * self-improvement loop.
+ *
+ * The problem this solves: behavioral rules live in `data/_memory/`, but a rule
+ * loaded at session start is *passive knowledge* — at action time the model's
+ * active context is full of the task and the rule slips. The documented result
+ * is the same failure recurring despite a registered rule. The fix is not
+ * another rule; it is a LEDGER that makes recurrence countable by a machine,
+ * plus an escalation ladder that turns counts into stronger defenses:
+ *
+ *   1st occurrence  → record (append-only file, one per occurrence)
+ *   2nd (rule held) → the rule's write-time gate becomes MANDATORY
+ *   3rd+            → propose promoting to a deterministic guard (hook /
+ *                     pre-commit / wrapper) — always a PROPOSAL; the user
+ *                     approves, nothing self-installs
+ *
+ * Design notes:
+ *  - One markdown file per occurrence (`YYYY-MM-DD_HHMM-<key>.md`), frontmatter
+ *    carries the machine-read fields; the body is for humans. Append-only —
+ *    resolving a pattern flips `status` on its entries, never deletes.
+ *  - `recurrence_key` is the grouping identity: a stable kebab-case name for
+ *    the ROOT CAUSE (e.g. `literal-control-bytes`), not the symptom of the day.
+ *    Same cause → same key, that is what makes counting honest.
+ *  - Recording is an agent ritual (auto, append-only, one-line note to the
+ *    user — AI-RULES "Default behaviors"); deterministic guards may also append
+ *    here directly so counting never depends on the failing agent noticing.
+ *  - The session-start report surfaces groups at 2+ open occurrences with their
+ *    ladder stage, so escalation never depends on human memory either.
+ */
+/** Directory name under `data/` holding the ledger. */
+declare const FAILURES_DIR = "_failures";
+/** Ladder stages by open-occurrence count. */
+type LadderStage = "recorded" | "gate" | "promote";
+/** Stage for a given open-occurrence count (1 → recorded, 2 → gate, 3+ → promote). */
+declare function ladderStage(count: number): LadderStage;
+/** One ledger entry (one occurrence), as read back from disk. */
+interface FailureEntry {
+    /** Path relative to the data dir (`_failures/2026-06-11_0210-….md`). */
+    readonly relPath: string;
+    readonly key: string;
+    readonly title: string;
+    readonly signal: string;
+    readonly severity: string;
+    readonly status: "open" | "resolved";
+    /** `YYYY-MM-DD` from frontmatter `created` (falls back to the filename). */
+    readonly date: string;
+    /** Related rule (memory slug) named at record time, or null. */
+    readonly rule: string | null;
+}
+/** All occurrences sharing a recurrence key, with the derived ladder stage. */
+interface FailureGroup {
+    readonly key: string;
+    /** OPEN occurrences only — resolved history no longer escalates. */
+    readonly count: number;
+    readonly stage: LadderStage;
+    readonly lastDate: string;
+    /** First non-null rule named across the group's entries. */
+    readonly rule: string | null;
+    readonly titles: readonly string[];
+    readonly entries: readonly FailureEntry[];
+}
+interface FailureScan {
+    /** Open groups, most occurrences first (ties: most recent first). */
+    readonly groups: readonly FailureGroup[];
+    readonly totalOpen: number;
+    readonly totalResolved: number;
+}
+interface RecordFailureInput {
+    /** Stable kebab-case root-cause key (`[a-z0-9-]`, 3..64 chars). */
+    readonly key: string;
+    /** One-line description of what happened. */
+    readonly what: string;
+    /** Signal class — free short token; conventional values: user_pushback, tool_error, test_failure, cross_check_miss, guard_denied, self_detected. */
+    readonly signal?: string;
+    /** low | medium | high (free token, those are the conventional values). */
+    readonly severity?: string;
+    /** Memory slug of the rule that already covered this (if any). */
+    readonly rule?: string;
+    /** Evidence pointers (paths, links) — recorded as a list in the body. */
+    readonly evidence?: readonly string[];
+}
+interface RecordFailureResult {
+    readonly path: string;
+    readonly relPath: string;
+    readonly key: string;
+    /** Open occurrences for this key AFTER this record (i.e. includes it). */
+    readonly count: number;
+    readonly stage: LadderStage;
+    /** Agent-facing one-liner explaining the ladder consequence of this count. */
+    readonly note: string;
+}
+/** Validate a recurrence key: stable kebab-case, filename-safe by construction. */
+declare function isValidFailureKey(key: string): boolean;
+/**
+ * Append one occurrence to the ledger. Creates `data/_failures/` on first use.
+ * Never overwrites: a same-minute collision for the same key gets a numeric
+ * suffix. Returns the post-write open count + ladder stage for the key so the
+ * caller (agent) can relay "this is the Nth time" in its one-line note.
+ */
+declare function recordFailure(dataDir: string, input: RecordFailureInput, now?: Date): Promise<RecordFailureResult>;
+declare function scanFailures(dataDir: string): Promise<FailureScan>;
+/** Compact, report-ready view: groups needing attention (2+ open occurrences). */
+interface FailureReportSlice {
+    readonly warnings: readonly {
+        readonly key: string;
+        readonly count: number;
+        readonly stage: LadderStage;
+        readonly rule: string | null;
+        readonly lastDate: string;
+    }[];
+    readonly totalOpen: number;
+    readonly omitted: number;
+}
+/** Slice a scan down to what the session-start report shows (stage gate/promote only, capped). */
+declare function failureReportSlice(scan: FailureScan): FailureReportSlice;
+/** The fixed recurrence key for write-guard denials (one failure class → one key). */
+declare const GUARD_DENIAL_KEY = "literal-control-bytes";
+/**
+ * Record a write-guard denial into the ledger — called by the guard itself, so
+ * counting NEVER depends on the failing agent noticing and self-reporting
+ * (the documented stall mode of self-report-only ledgers). Best-effort and
+ * silent: returns null when skipped (recent same-incident entry, or any
+ * error) — a ledger problem must never affect the deny itself.
+ */
+declare function recordGuardDenial(dataDir: string, what: string, now?: Date): Promise<RecordFailureResult | null>;
+/**
+ * Run the failure-ledger CLI. `record` appends one occurrence and reports the
+ * post-write count + ladder stage (so the agent can relay "Nth time"); `list`
+ * prints the grouped open ledger. Results are JSON on stdout.
+ */
+declare function runFailureCli(argv: readonly string[], dataDir: string, out: (s: string) => void, err: (s: string) => void): Promise<number>;
+
 interface ReindexResult {
     readonly dir: string;
     readonly status: "written" | "unchanged" | "missing";
@@ -4016,12 +4398,22 @@ type index_d_CurateResult = CurateResult;
 declare const index_d_DEFAULT_GAP_WINDOW_DAYS: typeof DEFAULT_GAP_WINDOW_DAYS;
 type index_d_EnsureHooksResult = EnsureHooksResult;
 type index_d_EnsureWorklogResult = EnsureWorklogResult;
+declare const index_d_FAILURES_DIR: typeof FAILURES_DIR;
+type index_d_FailureEntry = FailureEntry;
+type index_d_FailureGroup = FailureGroup;
+type index_d_FailureReportSlice = FailureReportSlice;
+type index_d_FailureScan = FailureScan;
+declare const index_d_GUARD_DENIAL_KEY: typeof GUARD_DENIAL_KEY;
+declare const index_d_GUARD_WRITE_COMMAND: typeof GUARD_WRITE_COMMAND;
+declare const index_d_GUARD_WRITE_MATCHER: typeof GUARD_WRITE_MATCHER;
 type index_d_GitPullResult = GitPullResult;
+type index_d_GuardFinding = GuardFinding;
 declare const index_d_HANDOFF_ARCHIVE_DIR: typeof HANDOFF_ARCHIVE_DIR;
 declare const index_d_HANDOFF_DIR: typeof HANDOFF_DIR;
 type index_d_HandoffCreateResult = HandoffCreateResult;
 type index_d_HandoffSummary = HandoffSummary;
 type index_d_HandoffWriteResult = HandoffWriteResult;
+type index_d_LadderStage = LadderStage;
 type index_d_NewDecisionResult = NewDecisionResult;
 declare const index_d_OWNERSHIP_SCHEMA: typeof OWNERSHIP_SCHEMA;
 type index_d_OpenDecision = OpenDecision;
@@ -4031,12 +4423,17 @@ type index_d_OwnershipEntry = OwnershipEntry;
 type index_d_OwnershipManifest = OwnershipManifest;
 type index_d_RecallOptions = RecallOptions;
 type index_d_RecentWorklog = RecentWorklog;
+type index_d_RecordFailureInput = RecordFailureInput;
+type index_d_RecordFailureResult = RecordFailureResult;
 type index_d_ReindexResult = ReindexResult;
 type index_d_RitualRegistryOptions = RitualRegistryOptions;
 declare const index_d_SESSION_END_COMMAND: typeof SESSION_END_COMMAND;
 declare const index_d_SESSION_START_COMMAND: typeof SESSION_START_COMMAND;
 type index_d_SessionStartHookReport = SessionStartHookReport;
 type index_d_SessionStartReport = SessionStartReport;
+type index_d_StatuslineData = StatuslineData;
+type index_d_StatuslineInstallResult = StatuslineInstallResult;
+type index_d_StatuslineProbes = StatuslineProbes;
 type index_d_UpdateCheckResult = UpdateCheckResult;
 type index_d_UpdateFileAction = UpdateFileAction;
 type index_d_UpdateFileActionKind = UpdateFileActionKind;
@@ -4055,6 +4452,7 @@ declare const index_d_aggregateHandoff: typeof aggregateHandoff;
 declare const index_d_applyGlobalSetup: typeof applyGlobalSetup;
 declare const index_d_argvToSlash: typeof argvToSlash;
 declare const index_d_autoReindexMemory: typeof autoReindexMemory;
+declare const index_d_buildDenyDecision: typeof buildDenyDecision;
 declare const index_d_buildInstallCommand: typeof buildInstallCommand;
 declare const index_d_buildOwnershipManifest: typeof buildOwnershipManifest;
 declare const index_d_buildRegistry: typeof buildRegistry;
@@ -4063,6 +4461,7 @@ declare const index_d_checkBaseUpdate: typeof checkBaseUpdate;
 declare const index_d_collectAgenda: typeof collectAgenda;
 declare const index_d_collectCarryover: typeof collectCarryover;
 declare const index_d_collectSessionStartReport: typeof collectSessionStartReport;
+declare const index_d_collectStatuslineProbes: typeof collectStatuslineProbes;
 declare const index_d_compareSemver: typeof compareSemver;
 declare const index_d_computeCurateFingerprint: typeof computeCurateFingerprint;
 declare const index_d_countUncommitted: typeof countUncommitted;
@@ -4073,53 +4472,76 @@ declare const index_d_curateCommand: typeof curateCommand;
 declare const index_d_decisionCommand: typeof decisionCommand;
 declare const index_d_detectInterruptedGitOp: typeof detectInterruptedGitOp;
 declare const index_d_detectWorklogGaps: typeof detectWorklogGaps;
+declare const index_d_effortMeter: typeof effortMeter;
+declare const index_d_ensureStatusline: typeof ensureStatusline;
 declare const index_d_ensureVortexHooks: typeof ensureVortexHooks;
 declare const index_d_ensureWorklogEntry: typeof ensureWorklogEntry;
 declare const index_d_extractNextUp: typeof extractNextUp;
 declare const index_d_extractOpenTasks: typeof extractOpenTasks;
+declare const index_d_failureReportSlice: typeof failureReportSlice;
+declare const index_d_findControlChar: typeof findControlChar;
+declare const index_d_formatTokens: typeof formatTokens;
+declare const index_d_formatWindow: typeof formatWindow;
 declare const index_d_gapWindowSinceArg: typeof gapWindowSinceArg;
 declare const index_d_globalMemoryPath: typeof globalMemoryPath;
 declare const index_d_globalSettingsHasHook: typeof globalSettingsHasHook;
 declare const index_d_globalSettingsPath: typeof globalSettingsPath;
 declare const index_d_globalStatePath: typeof globalStatePath;
+declare const index_d_guardWriteDecision: typeof guardWriteDecision;
 declare const index_d_handoffCommand: typeof handoffCommand;
 declare const index_d_inspectGlobalSetup: typeof inspectGlobalSetup;
 declare const index_d_inspectOwnership: typeof inspectOwnership;
 declare const index_d_isInstanceRoot: typeof isInstanceRoot;
 declare const index_d_isNewer: typeof isNewer;
 declare const index_d_isStableUpdate: typeof isStableUpdate;
+declare const index_d_isValidFailureKey: typeof isValidFailureKey;
+declare const index_d_ladderStage: typeof ladderStage;
 declare const index_d_logCommand: typeof logCommand;
+declare const index_d_makeBar: typeof makeBar;
 declare const index_d_ownershipManifestPath: typeof ownershipManifestPath;
 declare const index_d_parseAdoptArgs: typeof parseAdoptArgs;
 declare const index_d_parseSettings: typeof parseSettings;
+declare const index_d_parseStatuslineInput: typeof parseStatuslineInput;
 declare const index_d_pruneHandoffs: typeof pruneHandoffs;
 declare const index_d_queryNpmLatest: typeof queryNpmLatest;
 declare const index_d_readGlobalInstancePointer: typeof readGlobalInstancePointer;
 declare const index_d_readInstalledBaseVersion: typeof readInstalledBaseVersion;
 declare const index_d_recallCommand: typeof recallCommand;
+declare const index_d_recordFailure: typeof recordFailure;
 declare const index_d_recordGlobalSetupDecline: typeof recordGlobalSetupDecline;
+declare const index_d_recordGuardDenial: typeof recordGuardDenial;
 declare const index_d_reindexCommand: typeof reindexCommand;
 declare const index_d_renderAgenda: typeof renderAgenda;
 declare const index_d_renderGlobalBlock: typeof renderGlobalBlock;
 declare const index_d_renderSessionStartReport: typeof renderSessionStartReport;
+declare const index_d_renderStatusline: typeof renderStatusline;
 declare const index_d_repairOwnershipManifest: typeof repairOwnershipManifest;
+declare const index_d_resolveInstanceRoot: typeof resolveInstanceRoot;
 declare const index_d_resolveRepoRoot: typeof resolveRepoRoot;
 declare const index_d_runCurateAccept: typeof runCurateAccept;
 declare const index_d_runCurateCandidates: typeof runCurateCandidates;
 declare const index_d_runCurateDecline: typeof runCurateDecline;
 declare const index_d_runCuratePreview: typeof runCuratePreview;
+declare const index_d_runFailureCli: typeof runFailureCli;
+declare const index_d_runGuardCli: typeof runGuardCli;
+declare const index_d_runStatuslineCli: typeof runStatuslineCli;
 declare const index_d_runTemplatesUpdate: typeof runTemplatesUpdate;
 declare const index_d_runVortexCli: typeof runVortexCli;
+declare const index_d_safeSegment: typeof safeSegment;
+declare const index_d_scanFailures: typeof scanFailures;
 declare const index_d_scanHandoffs: typeof scanHandoffs;
+declare const index_d_scanToolInput: typeof scanToolInput;
 declare const index_d_serializeSettings: typeof serializeSettings;
 declare const index_d_sessionStartCommand: typeof sessionStartCommand;
+declare const index_d_sniffEffortFromTranscript: typeof sniffEffortFromTranscript;
+declare const index_d_statuslineCommand: typeof statuslineCommand;
 declare const index_d_templateDestRelPath: typeof templateDestRelPath;
 declare const index_d_upsertGlobalBlock: typeof upsertGlobalBlock;
 declare const index_d_validateCuratePayload: typeof validateCuratePayload;
 declare const index_d_vortexCommand: typeof vortexCommand;
 declare const index_d_writeOwnershipManifest: typeof writeOwnershipManifest;
 declare namespace index_d {
-  export { type index_d_AgendaReport as AgendaReport, type index_d_AmbientRecallFactoryOptions as AmbientRecallFactoryOptions, type index_d_CatchUpOptions as CatchUpOptions, type index_d_CatchUpResult as CatchUpResult, type index_d_ClaudeSettings as ClaudeSettings, type index_d_CliIo as CliIo, type index_d_CollectAgendaOptions as CollectAgendaOptions, type index_d_CurateAcceptResult as CurateAcceptResult, type index_d_CurateActionKind as CurateActionKind, type index_d_CurateAnyProposal as CurateAnyProposal, type index_d_CurateCandidate as CurateCandidate, type index_d_CurateCandidatesResult as CurateCandidatesResult, type index_d_CurateDeclineResult as CurateDeclineResult, type index_d_CurateOptions as CurateOptions, type index_d_CuratePayload as CuratePayload, type index_d_CuratePayloadValidation as CuratePayloadValidation, type index_d_CuratePreviewResult as CuratePreviewResult, type index_d_CurateResult as CurateResult, index_d_DEFAULT_GAP_WINDOW_DAYS as DEFAULT_GAP_WINDOW_DAYS, type index_d_EnsureHooksResult as EnsureHooksResult, type index_d_EnsureWorklogResult as EnsureWorklogResult, type index_d_GitPullResult as GitPullResult, index_d_HANDOFF_ARCHIVE_DIR as HANDOFF_ARCHIVE_DIR, index_d_HANDOFF_DIR as HANDOFF_DIR, type index_d_HandoffCreateResult as HandoffCreateResult, type index_d_HandoffSummary as HandoffSummary, type index_d_HandoffWriteResult as HandoffWriteResult, type index_d_NewDecisionResult as NewDecisionResult, index_d_OWNERSHIP_SCHEMA as OWNERSHIP_SCHEMA, type index_d_OpenDecision as OpenDecision, type index_d_OpenTask as OpenTask, type index_d_OwnershipDiagnosis as OwnershipDiagnosis, type index_d_OwnershipEntry as OwnershipEntry, type index_d_OwnershipManifest as OwnershipManifest, type index_d_RecallOptions as RecallOptions, type index_d_RecentWorklog as RecentWorklog, type index_d_ReindexResult as ReindexResult, type index_d_RitualRegistryOptions as RitualRegistryOptions, index_d_SESSION_END_COMMAND as SESSION_END_COMMAND, index_d_SESSION_START_COMMAND as SESSION_START_COMMAND, type index_d_SessionStartHookReport as SessionStartHookReport, type index_d_SessionStartReport as SessionStartReport, type index_d_UpdateCheckResult as UpdateCheckResult, type index_d_UpdateFileAction as UpdateFileAction, type index_d_UpdateFileActionKind as UpdateFileActionKind, type index_d_VortexHelpResult as VortexHelpResult, type index_d_VortexInitResult as VortexInitResult, type index_d_VortexPlannedResult as VortexPlannedResult, type index_d_VortexResult as VortexResult, type index_d_VortexSyncResult as VortexSyncResult, type index_d_VortexSyncStep as VortexSyncStep, type index_d_VortexSyncStepId as VortexSyncStepId, type index_d_VortexSyncStepStatus as VortexSyncStepStatus, type index_d_VortexUpdateResult as VortexUpdateResult, type index_d_WorklogAppendResult as WorklogAppendResult, index_d_agendaCommand as agendaCommand, index_d_aggregateHandoff as aggregateHandoff, index_d_applyGlobalSetup as applyGlobalSetup, index_d_argvToSlash as argvToSlash, index_d_autoReindexMemory as autoReindexMemory, index_d_buildInstallCommand as buildInstallCommand, index_d_buildOwnershipManifest as buildOwnershipManifest, index_d_buildRegistry as buildRegistry, index_d_catchUpSessions as catchUpSessions, index_d_checkBaseUpdate as checkBaseUpdate, index_d_collectAgenda as collectAgenda, index_d_collectCarryover as collectCarryover, index_d_collectSessionStartReport as collectSessionStartReport, index_d_compareSemver as compareSemver, index_d_computeCurateFingerprint as computeCurateFingerprint, index_d_countUncommitted as countUncommitted, index_d_createAmbientRecaller as createAmbientRecaller, index_d_createHandoffSkeleton as createHandoffSkeleton, index_d_createRitualRegistry as createRitualRegistry, index_d_curateCommand as curateCommand, index_d_decisionCommand as decisionCommand, index_d_detectInterruptedGitOp as detectInterruptedGitOp, index_d_detectWorklogGaps as detectWorklogGaps, index_d_ensureVortexHooks as ensureVortexHooks, index_d_ensureWorklogEntry as ensureWorklogEntry, index_d_extractNextUp as extractNextUp, index_d_extractOpenTasks as extractOpenTasks, index_d_gapWindowSinceArg as gapWindowSinceArg, index_d_globalMemoryPath as globalMemoryPath, index_d_globalSettingsHasHook as globalSettingsHasHook, index_d_globalSettingsPath as globalSettingsPath, index_d_globalStatePath as globalStatePath, index_d_handoffCommand as handoffCommand, index_d_inspectGlobalSetup as inspectGlobalSetup, index_d_inspectOwnership as inspectOwnership, index_d_isInstanceRoot as isInstanceRoot, index_d_isNewer as isNewer, index_d_isStableUpdate as isStableUpdate, index_d_logCommand as logCommand, index_d_ownershipManifestPath as ownershipManifestPath, index_d_parseAdoptArgs as parseAdoptArgs, index_d_parseSettings as parseSettings, index_d_pruneHandoffs as pruneHandoffs, index_d_queryNpmLatest as queryNpmLatest, index_d_readGlobalInstancePointer as readGlobalInstancePointer, index_d_readInstalledBaseVersion as readInstalledBaseVersion, index_d_recallCommand as recallCommand, index_d_recordGlobalSetupDecline as recordGlobalSetupDecline, index_d_reindexCommand as reindexCommand, index_d_renderAgenda as renderAgenda, index_d_renderGlobalBlock as renderGlobalBlock, index_d_renderSessionStartReport as renderSessionStartReport, index_d_repairOwnershipManifest as repairOwnershipManifest, index_d_resolveRepoRoot as resolveRepoRoot, index_d_runCurateAccept as runCurateAccept, index_d_runCurateCandidates as runCurateCandidates, index_d_runCurateDecline as runCurateDecline, index_d_runCuratePreview as runCuratePreview, index_d_runTemplatesUpdate as runTemplatesUpdate, index_d_runVortexCli as runVortexCli, index_d_scanHandoffs as scanHandoffs, index_d_serializeSettings as serializeSettings, index_d_sessionStartCommand as sessionStartCommand, index_d_templateDestRelPath as templateDestRelPath, index_d_upsertGlobalBlock as upsertGlobalBlock, index_d_validateCuratePayload as validateCuratePayload, index_d_vortexCommand as vortexCommand, index_d_writeOwnershipManifest as writeOwnershipManifest };
+  export { type index_d_AgendaReport as AgendaReport, type index_d_AmbientRecallFactoryOptions as AmbientRecallFactoryOptions, type index_d_CatchUpOptions as CatchUpOptions, type index_d_CatchUpResult as CatchUpResult, type index_d_ClaudeSettings as ClaudeSettings, type index_d_CliIo as CliIo, type index_d_CollectAgendaOptions as CollectAgendaOptions, type index_d_CurateAcceptResult as CurateAcceptResult, type index_d_CurateActionKind as CurateActionKind, type index_d_CurateAnyProposal as CurateAnyProposal, type index_d_CurateCandidate as CurateCandidate, type index_d_CurateCandidatesResult as CurateCandidatesResult, type index_d_CurateDeclineResult as CurateDeclineResult, type index_d_CurateOptions as CurateOptions, type index_d_CuratePayload as CuratePayload, type index_d_CuratePayloadValidation as CuratePayloadValidation, type index_d_CuratePreviewResult as CuratePreviewResult, type index_d_CurateResult as CurateResult, index_d_DEFAULT_GAP_WINDOW_DAYS as DEFAULT_GAP_WINDOW_DAYS, type index_d_EnsureHooksResult as EnsureHooksResult, type index_d_EnsureWorklogResult as EnsureWorklogResult, index_d_FAILURES_DIR as FAILURES_DIR, type index_d_FailureEntry as FailureEntry, type index_d_FailureGroup as FailureGroup, type index_d_FailureReportSlice as FailureReportSlice, type index_d_FailureScan as FailureScan, index_d_GUARD_DENIAL_KEY as GUARD_DENIAL_KEY, index_d_GUARD_WRITE_COMMAND as GUARD_WRITE_COMMAND, index_d_GUARD_WRITE_MATCHER as GUARD_WRITE_MATCHER, type index_d_GitPullResult as GitPullResult, type index_d_GuardFinding as GuardFinding, index_d_HANDOFF_ARCHIVE_DIR as HANDOFF_ARCHIVE_DIR, index_d_HANDOFF_DIR as HANDOFF_DIR, type index_d_HandoffCreateResult as HandoffCreateResult, type index_d_HandoffSummary as HandoffSummary, type index_d_HandoffWriteResult as HandoffWriteResult, type index_d_LadderStage as LadderStage, type index_d_NewDecisionResult as NewDecisionResult, index_d_OWNERSHIP_SCHEMA as OWNERSHIP_SCHEMA, type index_d_OpenDecision as OpenDecision, type index_d_OpenTask as OpenTask, type index_d_OwnershipDiagnosis as OwnershipDiagnosis, type index_d_OwnershipEntry as OwnershipEntry, type index_d_OwnershipManifest as OwnershipManifest, type index_d_RecallOptions as RecallOptions, type index_d_RecentWorklog as RecentWorklog, type index_d_RecordFailureInput as RecordFailureInput, type index_d_RecordFailureResult as RecordFailureResult, type index_d_ReindexResult as ReindexResult, type index_d_RitualRegistryOptions as RitualRegistryOptions, index_d_SESSION_END_COMMAND as SESSION_END_COMMAND, index_d_SESSION_START_COMMAND as SESSION_START_COMMAND, type index_d_SessionStartHookReport as SessionStartHookReport, type index_d_SessionStartReport as SessionStartReport, type index_d_StatuslineData as StatuslineData, type index_d_StatuslineInstallResult as StatuslineInstallResult, type index_d_StatuslineProbes as StatuslineProbes, type index_d_UpdateCheckResult as UpdateCheckResult, type index_d_UpdateFileAction as UpdateFileAction, type index_d_UpdateFileActionKind as UpdateFileActionKind, type index_d_VortexHelpResult as VortexHelpResult, type index_d_VortexInitResult as VortexInitResult, type index_d_VortexPlannedResult as VortexPlannedResult, type index_d_VortexResult as VortexResult, type index_d_VortexSyncResult as VortexSyncResult, type index_d_VortexSyncStep as VortexSyncStep, type index_d_VortexSyncStepId as VortexSyncStepId, type index_d_VortexSyncStepStatus as VortexSyncStepStatus, type index_d_VortexUpdateResult as VortexUpdateResult, type index_d_WorklogAppendResult as WorklogAppendResult, index_d_agendaCommand as agendaCommand, index_d_aggregateHandoff as aggregateHandoff, index_d_applyGlobalSetup as applyGlobalSetup, index_d_argvToSlash as argvToSlash, index_d_autoReindexMemory as autoReindexMemory, index_d_buildDenyDecision as buildDenyDecision, index_d_buildInstallCommand as buildInstallCommand, index_d_buildOwnershipManifest as buildOwnershipManifest, index_d_buildRegistry as buildRegistry, index_d_catchUpSessions as catchUpSessions, index_d_checkBaseUpdate as checkBaseUpdate, index_d_collectAgenda as collectAgenda, index_d_collectCarryover as collectCarryover, index_d_collectSessionStartReport as collectSessionStartReport, index_d_collectStatuslineProbes as collectStatuslineProbes, index_d_compareSemver as compareSemver, index_d_computeCurateFingerprint as computeCurateFingerprint, index_d_countUncommitted as countUncommitted, index_d_createAmbientRecaller as createAmbientRecaller, index_d_createHandoffSkeleton as createHandoffSkeleton, index_d_createRitualRegistry as createRitualRegistry, index_d_curateCommand as curateCommand, index_d_decisionCommand as decisionCommand, index_d_detectInterruptedGitOp as detectInterruptedGitOp, index_d_detectWorklogGaps as detectWorklogGaps, index_d_effortMeter as effortMeter, index_d_ensureStatusline as ensureStatusline, index_d_ensureVortexHooks as ensureVortexHooks, index_d_ensureWorklogEntry as ensureWorklogEntry, index_d_extractNextUp as extractNextUp, index_d_extractOpenTasks as extractOpenTasks, index_d_failureReportSlice as failureReportSlice, index_d_findControlChar as findControlChar, index_d_formatTokens as formatTokens, index_d_formatWindow as formatWindow, index_d_gapWindowSinceArg as gapWindowSinceArg, index_d_globalMemoryPath as globalMemoryPath, index_d_globalSettingsHasHook as globalSettingsHasHook, index_d_globalSettingsPath as globalSettingsPath, index_d_globalStatePath as globalStatePath, index_d_guardWriteDecision as guardWriteDecision, index_d_handoffCommand as handoffCommand, index_d_inspectGlobalSetup as inspectGlobalSetup, index_d_inspectOwnership as inspectOwnership, index_d_isInstanceRoot as isInstanceRoot, index_d_isNewer as isNewer, index_d_isStableUpdate as isStableUpdate, index_d_isValidFailureKey as isValidFailureKey, index_d_ladderStage as ladderStage, index_d_logCommand as logCommand, index_d_makeBar as makeBar, index_d_ownershipManifestPath as ownershipManifestPath, index_d_parseAdoptArgs as parseAdoptArgs, index_d_parseSettings as parseSettings, index_d_parseStatuslineInput as parseStatuslineInput, index_d_pruneHandoffs as pruneHandoffs, index_d_queryNpmLatest as queryNpmLatest, index_d_readGlobalInstancePointer as readGlobalInstancePointer, index_d_readInstalledBaseVersion as readInstalledBaseVersion, index_d_recallCommand as recallCommand, index_d_recordFailure as recordFailure, index_d_recordGlobalSetupDecline as recordGlobalSetupDecline, index_d_recordGuardDenial as recordGuardDenial, index_d_reindexCommand as reindexCommand, index_d_renderAgenda as renderAgenda, index_d_renderGlobalBlock as renderGlobalBlock, index_d_renderSessionStartReport as renderSessionStartReport, index_d_renderStatusline as renderStatusline, index_d_repairOwnershipManifest as repairOwnershipManifest, index_d_resolveInstanceRoot as resolveInstanceRoot, index_d_resolveRepoRoot as resolveRepoRoot, index_d_runCurateAccept as runCurateAccept, index_d_runCurateCandidates as runCurateCandidates, index_d_runCurateDecline as runCurateDecline, index_d_runCuratePreview as runCuratePreview, index_d_runFailureCli as runFailureCli, index_d_runGuardCli as runGuardCli, index_d_runStatuslineCli as runStatuslineCli, index_d_runTemplatesUpdate as runTemplatesUpdate, index_d_runVortexCli as runVortexCli, index_d_safeSegment as safeSegment, index_d_scanFailures as scanFailures, index_d_scanHandoffs as scanHandoffs, index_d_scanToolInput as scanToolInput, index_d_serializeSettings as serializeSettings, index_d_sessionStartCommand as sessionStartCommand, index_d_sniffEffortFromTranscript as sniffEffortFromTranscript, index_d_statuslineCommand as statuslineCommand, index_d_templateDestRelPath as templateDestRelPath, index_d_upsertGlobalBlock as upsertGlobalBlock, index_d_validateCuratePayload as validateCuratePayload, index_d_vortexCommand as vortexCommand, index_d_writeOwnershipManifest as writeOwnershipManifest };
 }
 
 export { index_d$9 as aiCodingPitfalls, index_d$d as core, index_d$a as dataLint, index_d$5 as decisionLog, index_d$4 as indexGenerator, index_d$2 as linkRewriter, index_d$b as memorySystem, index_d$1 as proactiveCurator, index_d$7 as reportGenerator, index_d$3 as runbooks, index_d as sessionRituals, index_d$c as slashCommands, index_d$8 as toolRules, index_d$6 as worklog };