@isaacriehm/cairn-core 0.1.0

package/dist/decision-capture/id.js

@@ -0,0 +1,60 @@
+/**
+ * Decision id allocator. DEC-NNNN, monotonic, never reused.
+ *
+ * Scans `.cairn/ground/decisions/` for accepted decisions AND
+ * `.cairn/ground/decisions/_inbox/` for outstanding drafts. Either counts
+ * toward the high-water mark — a draft that's pending operator confirmation
+ * still owns its id; rejecting a draft does NOT recycle the id.
+ *
+ * Single source of truth for DEC-id allocation. The MCP `record_decision`
+ * tool calls these helpers; do NOT re-implement the scan elsewhere.
+ */
+import { existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { decisionsDir } from "../ground/paths.js";
+const FILENAME_RE = /^DEC-(\d{4,})(?:\.draft|\.rejected)?\.md$/;
+/**
+ * Scan both the canonical decisions dir and the `_inbox/` for
+ * DEC-NNNN-prefixed files; return the set of ids found.
+ */
+export function scanExistingDecisionIds(repoRoot) {
+    const dir = decisionsDir(repoRoot);
+    const inboxDir = join(dir, "_inbox");
+    const ids = new Set();
+    for (const candidateDir of [dir, inboxDir]) {
+        if (!existsSync(candidateDir))
+            continue;
+        let entries;
+        try {
+            entries = readdirSync(candidateDir, { encoding: "utf8" });
+        }
+        catch {
+            continue;
+        }
+        for (const name of entries) {
+            const match = name.match(FILENAME_RE);
+            if (!match || !match[1])
+                continue;
+            ids.add(`DEC-${match[1].padStart(4, "0")}`);
+        }
+    }
+    return ids;
+}
+/**
+ * Return the next free `DEC-<NNNN>` id, optionally factoring in a
+ * caller-supplied set (e.g. ids the MCP tool just validated against).
+ */
+export function allocateDecisionId(repoRoot, existing) {
+    const ids = existing ?? scanExistingDecisionIds(repoRoot);
+    let max = 0;
+    for (const id of ids) {
+        const m = id.match(/^DEC-(\d+)$/);
+        if (!m?.[1])
+            continue;
+        const n = Number.parseInt(m[1], 10);
+        if (Number.isFinite(n) && n > max)
+            max = n;
+    }
+    return `DEC-${(max + 1).toString().padStart(4, "0")}`;
+}
+//# sourceMappingURL=id.js.map

package/dist/decision-capture/id.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"id.js","sourceRoot":"","sources":["../../src/decision-capture/id.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAClD,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,MAAM,WAAW,GAAG,2CAA2C,CAAC;AAEhE;;;GAGG;AACH,MAAM,UAAU,uBAAuB,CAAC,QAAgB;IACtD,MAAM,GAAG,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAC;IACnC,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;IACrC,MAAM,GAAG,GAAG,IAAI,GAAG,EAAU,CAAC;IAC9B,KAAK,MAAM,YAAY,IAAI,CAAC,GAAG,EAAE,QAAQ,CAAC,EAAE,CAAC;QAC3C,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC;YAAE,SAAS;QACxC,IAAI,OAAiB,CAAC;QACtB,IAAI,CAAC;YACH,OAAO,GAAG,WAAW,CAAC,YAAY,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC,CAAC;QAC5D,CAAC;QAAC,MAAM,CAAC;YACP,SAAS;QACX,CAAC;QACD,KAAK,MAAM,IAAI,IAAI,OAAO,EAAE,CAAC;YAC3B,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;YACtC,IAAI,CAAC,KAAK,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;gBAAE,SAAS;YAClC,GAAG,CAAC,GAAG,CAAC,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC;QAC9C,CAAC;IACH,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,kBAAkB,CAChC,QAAgB,EAChB,QAAsB;IAEtB,MAAM,GAAG,GAAG,QAAQ,IAAI,uBAAuB,CAAC,QAAQ,CAAC,CAAC;IAC1D,IAAI,GAAG,GAAG,CAAC,CAAC;IACZ,KAAK,MAAM,EAAE,IAAI,GAAG,EAAE,CAAC;QACrB,MAAM,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;QAClC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;YAAE,SAAS;QACtB,MAAM,CAAC,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QACpC,IAAI,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,GAAG;YAAE,GAAG,GAAG,CAAC,CAAC;IAC7C,CAAC;IACD,OAAO,OAAO,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC;AACxD,CAAC"}

package/dist/decision-capture/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Phase 14 — decision capture flow.
+ *
+ * Public surface:
+ *   - runDecisionCapture(args)        → end-to-end (extract → draft → confirm → ledger)
+ *   - runDecisionExtractor(input)     → standalone Tier-1 call
+ *   - allocateDecisionId(repoRoot)    → next monotonic DEC-id
+ *   - writeDecisionDraft, acceptDraft, rejectDraft — mechanical persistence
+ *   - DECISION_EXTRACTOR_OUTPUT_SCHEMA, DECISION_EXTRACTOR_SYSTEM_PROMPT — for
+ *     consumers that want to call `runClaude` directly
+ */
+export type { CandidateAssertion, DecisionCaptureResult, DecisionDraft, DecisionExtractorInput, DecisionExtractorOutput, DraftConfirmDecision, ConfirmResult, RefinementProposal, RefinementResult, RefinerInput, RefinerOutput, } from "./types.js";
+export { allocateDecisionId, scanExistingDecisionIds } from "./id.js";
+export { DECISION_EXTRACTOR_SYSTEM_PROMPT, buildDecisionExtractorUserPrompt, } from "./prompt.js";
+export { DECISION_EXTRACTOR_OUTPUT_SCHEMA } from "./schema.js";
+export { runDecisionExtractor } from "./extractor.js";
+export type { ExtractorResult } from "./extractor.js";
+export { acceptDraft, liftCandidatesToAssertions, rejectDraft, writeDecisionDraft, } from "./writer.js";
+export type { AcceptDraftResult, LiftResult, LiftVerdict, WriteDecisionDraftArgs, } from "./writer.js";
+export { runDecisionCapture } from "./capture.js";
+export type { RunDecisionCaptureArgs } from "./capture.js";
+export { REFINEMENT_PROPOSER_SYSTEM_PROMPT, buildRefinementProposerUserPrompt, } from "./refinement-prompt.js";
+export { REFINEMENT_PROPOSER_OUTPUT_SCHEMA } from "./refinement-schema.js";
+export { proposeStrictAssertions, runDecisionRefinement, } from "./refinement.js";
+export type { ProposerResult, RunDecisionRefinementArgs, } from "./refinement.js";

package/dist/decision-capture/index.js

@@ -0,0 +1,21 @@
+/**
+ * Phase 14 — decision capture flow.
+ *
+ * Public surface:
+ *   - runDecisionCapture(args)        → end-to-end (extract → draft → confirm → ledger)
+ *   - runDecisionExtractor(input)     → standalone Tier-1 call
+ *   - allocateDecisionId(repoRoot)    → next monotonic DEC-id
+ *   - writeDecisionDraft, acceptDraft, rejectDraft — mechanical persistence
+ *   - DECISION_EXTRACTOR_OUTPUT_SCHEMA, DECISION_EXTRACTOR_SYSTEM_PROMPT — for
+ *     consumers that want to call `runClaude` directly
+ */
+export { allocateDecisionId, scanExistingDecisionIds } from "./id.js";
+export { DECISION_EXTRACTOR_SYSTEM_PROMPT, buildDecisionExtractorUserPrompt, } from "./prompt.js";
+export { DECISION_EXTRACTOR_OUTPUT_SCHEMA } from "./schema.js";
+export { runDecisionExtractor } from "./extractor.js";
+export { acceptDraft, liftCandidatesToAssertions, rejectDraft, writeDecisionDraft, } from "./writer.js";
+export { runDecisionCapture } from "./capture.js";
+export { REFINEMENT_PROPOSER_SYSTEM_PROMPT, buildRefinementProposerUserPrompt, } from "./refinement-prompt.js";
+export { REFINEMENT_PROPOSER_OUTPUT_SCHEMA } from "./refinement-schema.js";
+export { proposeStrictAssertions, runDecisionRefinement, } from "./refinement.js";
+//# sourceMappingURL=index.js.map

package/dist/decision-capture/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/decision-capture/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAgBH,OAAO,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAC;AACtE,OAAO,EACL,gCAAgC,EAChC,gCAAgC,GACjC,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,gCAAgC,EAAE,MAAM,aAAa,CAAC;AAC/D,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAEtD,OAAO,EACL,WAAW,EACX,0BAA0B,EAC1B,WAAW,EACX,kBAAkB,GACnB,MAAM,aAAa,CAAC;AAOrB,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAElD,OAAO,EACL,iCAAiC,EACjC,iCAAiC,GAClC,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,iCAAiC,EAAE,MAAM,wBAAwB,CAAC;AAC3E,OAAO,EACL,uBAAuB,EACvB,qBAAqB,GACtB,MAAM,iBAAiB,CAAC"}

package/dist/decision-capture/prompt.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Decision-extractor prompts.
+ *
+ * Operator submits a direction (slash arg or free-text classified as
+ * `direction`). The extractor distills it into a typed candidate the
+ * cairn materializes into a draft decision.
+ *
+ * Anti-fabrication framing: when the input isn't actually a direction
+ * (rambling, off-topic, a question), the extractor sets
+ * `not_a_decision=true` and the cairn short-circuits without writing a
+ * draft. This keeps the decisions ledger free of noise.
+ */
+import type { DecisionExtractorInput } from "./types.js";
+export declare const DECISION_EXTRACTOR_SYSTEM_PROMPT = "You are the **decision-extractor** for an agent cairn. The operator just spoke a direction \u2014 a binding course-change like \"from now on, X\" or \"scrap that, go with Y\" or \"user_id always required on integration tables\". Your job is to capture it as a typed candidate decision so the cairn can present it for confirmation.\n\nYou read three things:\n1. The raw direction text the operator submitted.\n2. Author / source / received-at metadata for the audit record.\n3. (Optional) A short list of currently-accepted decisions so you can spot supersedes relationships.\n\nYou emit a single JSON object matching the supplied schema. Required fields:\n\n- `subject`: imperative one-line title. Example: \"Filter integration_oauth_tokens queries by user_id\".\n- `summary`: 2-4 sentence paragraph expanding the subject. Capture the *what* and the *why* as the operator stated them \u2014 do NOT invent rationale they didn't give.\n- `scope_globs`: repo-relative globs the decision binds. Be specific. `[\"core/src/integrations/**/*.ts\"]` is good; `[\"**/*.ts\"]` is almost always wrong. When you genuinely can't tell, emit `[]` and let the operator narrow at confirm time.\n- `supersedes`: if the input EXPLICITLY revokes a previously-accepted decision (`scrap DEC-0042`, `undo the FK denorm rule`), set the DEC-id. Otherwise null/omit.\n- `candidate_assertions`: 0-3 mechanical-sensor checks that would enforce the decision going forward. Pick the kind from the schema enum that fits. ZERO is a valid answer when the rule is purely conceptual \u2014 better than fabricating an assertion that can't actually be verified.\n- `confidence_signal`: `high` when the direction is unambiguous + scope is obvious; `medium` when one of those is shaky; `low` when both are.\n- `not_a_decision`: set TRUE if the input is rambling, off-topic, a question rather than a directive, or otherwise lacks a binding rule. The cairn will short-circuit without writing a draft. When in doubt, set true \u2014 false-positive drafts pollute the ledger; false-negatives are recoverable via re-submission.\n\nExamples of inputs that should map to `not_a_decision: true`:\n- \"what's the status?\"\n- \"I'm thinking about switching to FK denorm but not sure\"  \u2190 thinking-out-loud, not yet binding\n- \"lol\"\n- \"remind me about Phase 12\"\n\nExamples that should map to `not_a_decision: false`:\n- \"scrap that \u2014 going forward, FK denormalization only\"  \u2190 supersedes implicit\n- \"all integration_oauth_tokens queries must filter by user_id\"  \u2190 clear assertion candidate\n- \"from now on, no new code in core/src/legacy\"  \u2190 scope_globs + file_must_not_be_modified\n\nYour candidate_assertions are *proposals* \u2014 the operator gets one more chance to edit them at the confirm dialog. Don't over-commit; aim for the smallest set of assertions that mechanically captures the binding behavior, not every implication.\n\nOutput ONLY the JSON object. No prose, no code fences, no other content.";
+export declare function buildDecisionExtractorUserPrompt(input: DecisionExtractorInput): string;

package/dist/decision-capture/prompt.js

@@ -0,0 +1,68 @@
+/**
+ * Decision-extractor prompts.
+ *
+ * Operator submits a direction (slash arg or free-text classified as
+ * `direction`). The extractor distills it into a typed candidate the
+ * cairn materializes into a draft decision.
+ *
+ * Anti-fabrication framing: when the input isn't actually a direction
+ * (rambling, off-topic, a question), the extractor sets
+ * `not_a_decision=true` and the cairn short-circuits without writing a
+ * draft. This keeps the decisions ledger free of noise.
+ */
+const PER_DIRECTION_CHAR_CAP = 6_000;
+export const DECISION_EXTRACTOR_SYSTEM_PROMPT = `You are the **decision-extractor** for an agent cairn. The operator just spoke a direction — a binding course-change like "from now on, X" or "scrap that, go with Y" or "user_id always required on integration tables". Your job is to capture it as a typed candidate decision so the cairn can present it for confirmation.
+
+You read three things:
+1. The raw direction text the operator submitted.
+2. Author / source / received-at metadata for the audit record.
+3. (Optional) A short list of currently-accepted decisions so you can spot supersedes relationships.
+
+You emit a single JSON object matching the supplied schema. Required fields:
+
+- \`subject\`: imperative one-line title. Example: "Filter integration_oauth_tokens queries by user_id".
+- \`summary\`: 2-4 sentence paragraph expanding the subject. Capture the *what* and the *why* as the operator stated them — do NOT invent rationale they didn't give.
+- \`scope_globs\`: repo-relative globs the decision binds. Be specific. \`["core/src/integrations/**/*.ts"]\` is good; \`["**/*.ts"]\` is almost always wrong. When you genuinely can't tell, emit \`[]\` and let the operator narrow at confirm time.
+- \`supersedes\`: if the input EXPLICITLY revokes a previously-accepted decision (\`scrap DEC-0042\`, \`undo the FK denorm rule\`), set the DEC-id. Otherwise null/omit.
+- \`candidate_assertions\`: 0-3 mechanical-sensor checks that would enforce the decision going forward. Pick the kind from the schema enum that fits. ZERO is a valid answer when the rule is purely conceptual — better than fabricating an assertion that can't actually be verified.
+- \`confidence_signal\`: \`high\` when the direction is unambiguous + scope is obvious; \`medium\` when one of those is shaky; \`low\` when both are.
+- \`not_a_decision\`: set TRUE if the input is rambling, off-topic, a question rather than a directive, or otherwise lacks a binding rule. The cairn will short-circuit without writing a draft. When in doubt, set true — false-positive drafts pollute the ledger; false-negatives are recoverable via re-submission.
+
+Examples of inputs that should map to \`not_a_decision: true\`:
+- "what's the status?"
+- "I'm thinking about switching to FK denorm but not sure"  ← thinking-out-loud, not yet binding
+- "lol"
+- "remind me about Phase 12"
+
+Examples that should map to \`not_a_decision: false\`:
+- "scrap that — going forward, FK denormalization only"  ← supersedes implicit
+- "all integration_oauth_tokens queries must filter by user_id"  ← clear assertion candidate
+- "from now on, no new code in core/src/legacy"  ← scope_globs + file_must_not_be_modified
+
+Your candidate_assertions are *proposals* — the operator gets one more chance to edit them at the confirm dialog. Don't over-commit; aim for the smallest set of assertions that mechanically captures the binding behavior, not every implication.
+
+Output ONLY the JSON object. No prose, no code fences, no other content.`;
+export function buildDecisionExtractorUserPrompt(input) {
+    const sections = [];
+    sections.push("## Raw direction text");
+    const text = input.raw_text.trim();
+    sections.push(text.length > PER_DIRECTION_CHAR_CAP
+        ? text.slice(0, PER_DIRECTION_CHAR_CAP) +
+            `\n…[truncated; ${text.length - PER_DIRECTION_CHAR_CAP} chars elided]`
+        : text);
+    sections.push("\n## Metadata");
+    sections.push(`author: ${input.author_id}`);
+    sections.push(`source: ${input.source}`);
+    sections.push(`received_at: ${input.received_at}`);
+    if (input.accepted_decisions && input.accepted_decisions.length > 0) {
+        sections.push("\n## Currently-accepted decisions (most recent first)");
+        for (const d of input.accepted_decisions.slice(0, 10)) {
+            sections.push(`- **${d.id}** — ${d.title}  (${d.scope_summary})`);
+        }
+        sections.push("\nIf the new direction explicitly revokes one of these, set `supersedes` to its id.");
+    }
+    sections.push("\n## Your task");
+    sections.push("Extract the decision per the schema. Emit ONLY the JSON object.");
+    return sections.join("\n");
+}
+//# sourceMappingURL=prompt.js.map

package/dist/decision-capture/prompt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt.js","sourceRoot":"","sources":["../../src/decision-capture/prompt.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,MAAM,sBAAsB,GAAG,KAAK,CAAC;AAErC,MAAM,CAAC,MAAM,gCAAgC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yEA8ByB,CAAC;AAE1E,MAAM,UAAU,gCAAgC,CAC9C,KAA6B;IAE7B,MAAM,QAAQ,GAAa,EAAE,CAAC;IAC9B,QAAQ,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAC;IACvC,MAAM,IAAI,GAAG,KAAK,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;IACnC,QAAQ,CAAC,IAAI,CACX,IAAI,CAAC,MAAM,GAAG,sBAAsB;QAClC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,sBAAsB,CAAC;YACnC,kBAAkB,IAAI,CAAC,MAAM,GAAG,sBAAsB,gBAAgB;QAC1E,CAAC,CAAC,IAAI,CACT,CAAC;IAEF,QAAQ,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;IAC/B,QAAQ,CAAC,IAAI,CAAC,WAAW,KAAK,CAAC,SAAS,EAAE,CAAC,CAAC;IAC5C,QAAQ,CAAC,IAAI,CAAC,WAAW,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC;IACzC,QAAQ,CAAC,IAAI,CAAC,gBAAgB,KAAK,CAAC,WAAW,EAAE,CAAC,CAAC;IAEnD,IAAI,KAAK,CAAC,kBAAkB,IAAI,KAAK,CAAC,kBAAkB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACpE,QAAQ,CAAC,IAAI,CAAC,uDAAuD,CAAC,CAAC;QACvE,KAAK,MAAM,CAAC,IAAI,KAAK,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;YACtD,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,aAAa,GAAG,CAAC,CAAC;QACpE,CAAC;QACD,QAAQ,CAAC,IAAI,CACX,qFAAqF,CACtF,CAAC;IACJ,CAAC;IAED,QAAQ,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;IAChC,QAAQ,CAAC,IAAI,CACX,iEAAiE,CAClE,CAAC;IAEF,OAAO,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC7B,CAAC"}

package/dist/decision-capture/refinement-prompt.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Assertion-refiner prompts.
+ *
+ * The decision-extractor (Phase 14) emits LOOSE candidate assertions —
+ * `{kind, description, parameters?}` with `parameters` schema-loose. The
+ * decision file stores them under frontmatter `candidate_assertions:`,
+ * NOT under `assertions:` which Layer-D sensors enforce.
+ *
+ * The refiner's job is to lift each candidate into a STRICT shape that
+ * matches one of the eleven `DecisionAssertion` kinds (see
+ * `src/ground/schemas.ts`). When a candidate is too vague to form
+ * confident strict params, the refiner DEMOTES it to
+ * `human_review_hint` (always soft, always passes zod). When the
+ * candidate description is sound but the strict params would need
+ * operator input the refiner can't infer, it SKIPS — the candidate
+ * survives in `candidate_assertions:` for the next refine pass.
+ *
+ * Anti-fabrication framing: prefer demote / skip over inventing wrong
+ * regex / globs / table names. A wrong assertion is a sensor that fires
+ * on every PR forever; a `human_review_hint` is at worst noise in the
+ * reviewer's pre-amble.
+ */
+import type { RefinerInput } from "./types.js";
+export declare const REFINEMENT_PROPOSER_SYSTEM_PROMPT = "You are the **assertion-refiner** for an agent cairn. The operator just confirmed a binding decision; the decision-extractor proposed N loose candidate assertions to enforce it. Your job is to lift each candidate into the STRICT shape used by the cairn's mechanical sensors, OR demote / skip it.\n\n## The eleven assertion kinds\n\nEach kind requires specific fields. The cairn's zod re-validates at apply time; a malformed `strict_assertion` is auto-demoted, so don't fudge \u2014 when you don't have a confident value for a required field, set status=\"demote\" or status=\"skip\" instead.\n\n- **schema_must_contain** \u2014 { table: string, column: string, column_type?: string, nullable?: boolean }\n  Migration / schema rule. Example: \"tokens table must have user_id column NOT NULL\".\n\n- **text_must_match** \u2014 { pattern: string (JS regex source), in_globs: string[] }\n  Some text must appear in matching files. Example: license header in src/**/*.ts.\n\n- **text_must_not_match** \u2014 { pattern: string, in_globs: string[] }\n  Some text must NOT appear. Example: \"no `process.env.` access in src/**/*.ts\".\n\n- **index_must_exist** \u2014 { table: string, columns: string[], where?: string }\n  Database index. Example: \"(provider, user_id) WHERE archived_at IS NULL on tokens\".\n\n- **ast_pattern** \u2014 { language: string (\"ts\"|\"py\"|\"go\"|...), pattern: string (regex fallback), in_globs: string[] }\n  Structural pattern. Example: \"all controllers extend BaseController\".\n\n- **file_must_not_be_modified** \u2014 { path: string }\n  Frozen file. Example: \"core/src/legacy/billing.ts\".\n\n- **query_must_filter_by** \u2014 { orm: string (\"drizzle\"|\"prisma\"|\"sqlalchemy\"|...), in_globs: string[], table: string, columns: string[], operator: \"eq\"|\"in\"|\"between\"|\"is_not_null\", require_combination: \"and\"|\"or\" }\n  ORM-level scope. Example: \"all integration_oauth_tokens queries filter by user_id eq AND provider eq\".\n\n- **route_must_have_guard** \u2014 { in_globs: string[], guard: string, require_on: string[] }\n  HTTP guard. Example: \"all routes in api/*/admin.ts have RequireRole guard, require_on: [GET, POST]\".\n\n- **event_must_emit** \u2014 { in_globs: string[], after_method: string, event_key: string, payload_must_include?: string[] }\n  Event emission. Example: \"after createInvoice() emit invoice.created with [invoice_id, user_id]\".\n\n- **service_method_must_call** \u2014 { in_globs: string[], in_method: string, must_call: string, before_returning?: boolean }\n  Required call inside method. Example: \"in TokenService.refresh(), must call audit.log() before returning\".\n\n- **human_review_hint** \u2014 { description: string }\n  Always-soft fallback. Use this for purely conceptual rules (\"prefer simple solutions\", \"avoid magic numbers in pricing logic\").\n\n## Per-candidate verdict\n\nFor each candidate, emit one proposal:\n\n```\n{\n  candidate_id: <as given>,\n  candidate_kind: <as given>,\n  status: \"lift\" | \"demote\" | \"skip\",\n  confidence_signal: \"high\" | \"medium\" | \"low\",\n  strict_assertion?: { ... }   // present iff status=\"lift\"\n  rationale: \"one sentence explaining the choice\"\n}\n```\n\n### When to LIFT\n\nYou are confident on every required field for the candidate's kind. The description gave you concrete table / file / regex / glob names, and the decision's scope_globs lets you narrow the in_globs reasonably.\n\nIf the candidate kind is **human_review_hint**, ALWAYS lift \u2014 the kind already has a single-field shape. `description` is the candidate's existing description.\n\n### When to DEMOTE\n\nThe candidate description is sound but the strict params would require input you don't have (e.g., \"no env vars\" \u2014 needs the actual regex pattern; \"must filter by user_id\" \u2014 needs the ORM name and table name and you don't know which).\n\nDemote means: rewrite as `human_review_hint` with a description that captures the rule's intent. The operator + reviewer + UAT still see it; sensors don't enforce it. Better than a hallucinated regex that fires on every PR.\n\n### When to SKIP\n\nThe candidate is weakly-specified to the point that even `human_review_hint` would be too vague to be useful (e.g., the operator's description was \"fix the thing\", the kind doesn't match the description, etc.). Skip leaves it under `candidate_assertions:` for a future refine pass.\n\n## Confidence\n\n- `high`: required fields are explicit in the candidate description. No guesses.\n- `medium`: most fields present, one or two reasonable inferences from scope_globs / decision summary.\n- `low`: status=\"lift\" with low confidence is a defect. Use status=\"demote\" or \"skip\" instead.\n\n## Output\n\nEmit ONLY the JSON object: `{ \"proposals\": [...] }`. One proposal per input candidate, in the order given. No prose, no code fences.";
+export declare function buildRefinementProposerUserPrompt(input: RefinerInput): string;

package/dist/decision-capture/refinement-prompt.js

@@ -0,0 +1,146 @@
+/**
+ * Assertion-refiner prompts.
+ *
+ * The decision-extractor (Phase 14) emits LOOSE candidate assertions —
+ * `{kind, description, parameters?}` with `parameters` schema-loose. The
+ * decision file stores them under frontmatter `candidate_assertions:`,
+ * NOT under `assertions:` which Layer-D sensors enforce.
+ *
+ * The refiner's job is to lift each candidate into a STRICT shape that
+ * matches one of the eleven `DecisionAssertion` kinds (see
+ * `src/ground/schemas.ts`). When a candidate is too vague to form
+ * confident strict params, the refiner DEMOTES it to
+ * `human_review_hint` (always soft, always passes zod). When the
+ * candidate description is sound but the strict params would need
+ * operator input the refiner can't infer, it SKIPS — the candidate
+ * survives in `candidate_assertions:` for the next refine pass.
+ *
+ * Anti-fabrication framing: prefer demote / skip over inventing wrong
+ * regex / globs / table names. A wrong assertion is a sensor that fires
+ * on every PR forever; a `human_review_hint` is at worst noise in the
+ * reviewer's pre-amble.
+ */
+const PER_DECISION_CHAR_CAP = 4_000;
+export const REFINEMENT_PROPOSER_SYSTEM_PROMPT = `You are the **assertion-refiner** for an agent cairn. The operator just confirmed a binding decision; the decision-extractor proposed N loose candidate assertions to enforce it. Your job is to lift each candidate into the STRICT shape used by the cairn's mechanical sensors, OR demote / skip it.
+
+## The eleven assertion kinds
+
+Each kind requires specific fields. The cairn's zod re-validates at apply time; a malformed \`strict_assertion\` is auto-demoted, so don't fudge — when you don't have a confident value for a required field, set status="demote" or status="skip" instead.
+
+- **schema_must_contain** — { table: string, column: string, column_type?: string, nullable?: boolean }
+  Migration / schema rule. Example: "tokens table must have user_id column NOT NULL".
+
+- **text_must_match** — { pattern: string (JS regex source), in_globs: string[] }
+  Some text must appear in matching files. Example: license header in src/**/*.ts.
+
+- **text_must_not_match** — { pattern: string, in_globs: string[] }
+  Some text must NOT appear. Example: "no \`process.env.\` access in src/**/*.ts".
+
+- **index_must_exist** — { table: string, columns: string[], where?: string }
+  Database index. Example: "(provider, user_id) WHERE archived_at IS NULL on tokens".
+
+- **ast_pattern** — { language: string ("ts"|"py"|"go"|...), pattern: string (regex fallback), in_globs: string[] }
+  Structural pattern. Example: "all controllers extend BaseController".
+
+- **file_must_not_be_modified** — { path: string }
+  Frozen file. Example: "core/src/legacy/billing.ts".
+
+- **query_must_filter_by** — { orm: string ("drizzle"|"prisma"|"sqlalchemy"|...), in_globs: string[], table: string, columns: string[], operator: "eq"|"in"|"between"|"is_not_null", require_combination: "and"|"or" }
+  ORM-level scope. Example: "all integration_oauth_tokens queries filter by user_id eq AND provider eq".
+
+- **route_must_have_guard** — { in_globs: string[], guard: string, require_on: string[] }
+  HTTP guard. Example: "all routes in api/*/admin.ts have RequireRole guard, require_on: [GET, POST]".
+
+- **event_must_emit** — { in_globs: string[], after_method: string, event_key: string, payload_must_include?: string[] }
+  Event emission. Example: "after createInvoice() emit invoice.created with [invoice_id, user_id]".
+
+- **service_method_must_call** — { in_globs: string[], in_method: string, must_call: string, before_returning?: boolean }
+  Required call inside method. Example: "in TokenService.refresh(), must call audit.log() before returning".
+
+- **human_review_hint** — { description: string }
+  Always-soft fallback. Use this for purely conceptual rules ("prefer simple solutions", "avoid magic numbers in pricing logic").
+
+## Per-candidate verdict
+
+For each candidate, emit one proposal:
+
+\`\`\`
+{
+  candidate_id: <as given>,
+  candidate_kind: <as given>,
+  status: "lift" | "demote" | "skip",
+  confidence_signal: "high" | "medium" | "low",
+  strict_assertion?: { ... }   // present iff status="lift"
+  rationale: "one sentence explaining the choice"
+}
+\`\`\`
+
+### When to LIFT
+
+You are confident on every required field for the candidate's kind. The description gave you concrete table / file / regex / glob names, and the decision's scope_globs lets you narrow the in_globs reasonably.
+
+If the candidate kind is **human_review_hint**, ALWAYS lift — the kind already has a single-field shape. \`description\` is the candidate's existing description.
+
+### When to DEMOTE
+
+The candidate description is sound but the strict params would require input you don't have (e.g., "no env vars" — needs the actual regex pattern; "must filter by user_id" — needs the ORM name and table name and you don't know which).
+
+Demote means: rewrite as \`human_review_hint\` with a description that captures the rule's intent. The operator + reviewer + UAT still see it; sensors don't enforce it. Better than a hallucinated regex that fires on every PR.
+
+### When to SKIP
+
+The candidate is weakly-specified to the point that even \`human_review_hint\` would be too vague to be useful (e.g., the operator's description was "fix the thing", the kind doesn't match the description, etc.). Skip leaves it under \`candidate_assertions:\` for a future refine pass.
+
+## Confidence
+
+- \`high\`: required fields are explicit in the candidate description. No guesses.
+- \`medium\`: most fields present, one or two reasonable inferences from scope_globs / decision summary.
+- \`low\`: status="lift" with low confidence is a defect. Use status="demote" or "skip" instead.
+
+## Output
+
+Emit ONLY the JSON object: \`{ "proposals": [...] }\`. One proposal per input candidate, in the order given. No prose, no code fences.`;
+export function buildRefinementProposerUserPrompt(input) {
+    const sections = [];
+    sections.push(`## Decision context — ${input.decision_id}`);
+    sections.push(`subject: ${input.subject}`);
+    const summary = input.summary.trim();
+    sections.push("");
+    sections.push("summary:");
+    sections.push(summary.length > PER_DECISION_CHAR_CAP
+        ? summary.slice(0, PER_DECISION_CHAR_CAP) +
+            `\n…[truncated; ${summary.length - PER_DECISION_CHAR_CAP} chars elided]`
+        : summary);
+    if (input.scope_globs.length > 0) {
+        sections.push("");
+        sections.push("scope_globs:");
+        for (const g of input.scope_globs)
+            sections.push(`  - ${g}`);
+    }
+    else {
+        sections.push("");
+        sections.push("scope_globs: (none — operator left it unspecified)");
+    }
+    sections.push("");
+    sections.push("## Candidates to refine");
+    for (let i = 0; i < input.candidates.length; i++) {
+        const c = input.candidates[i];
+        if (c === undefined)
+            continue;
+        const id = c.id ?? `${input.decision_id}-A${(i + 1).toString().padStart(2, "0")}`;
+        sections.push("");
+        sections.push(`### ${id}  (kind: ${c.kind})`);
+        sections.push(`description: ${c.description}`);
+        if (c.parameters && Object.keys(c.parameters).length > 0) {
+            sections.push("parameters (loose, from extractor):");
+            sections.push("```json");
+            sections.push(JSON.stringify(c.parameters, null, 2));
+            sections.push("```");
+        }
+    }
+    sections.push("");
+    sections.push("## Your task");
+    sections.push("Emit one proposal per candidate in the order given. Use the candidate_id values shown above. Output ONLY the JSON object.");
+    return sections.join("\n");
+}
+//# sourceMappingURL=refinement-prompt.js.map

package/dist/decision-capture/refinement-prompt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"refinement-prompt.js","sourceRoot":"","sources":["../../src/decision-capture/refinement-prompt.ts"],"names":[],"mappings":"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"}

package/dist/decision-capture/refinement-schema.d.ts

@@ -0,0 +1,52 @@
+/**
+ * JSON Schema enforced by `claude --json-schema` for the assertion-refiner
+ * proposer output.
+ *
+ * For each input candidate the proposer returns one `RefinementProposal`.
+ * The shape here is intentionally loose on `strict_assertion` — the
+ * production `DecisionAssertion` zod (see `src/ground/schemas.ts`) is the
+ * source of truth and re-validates at apply time. Forcing the discriminated
+ * union into JSON Schema and the proposer's prompt would burn tokens
+ * without buying additional safety, since malformed shapes auto-demote.
+ *
+ * The proposer's per-kind contract is encoded in the system prompt
+ * (`refinement-prompt.ts`), not here.
+ */
+export declare const REFINEMENT_PROPOSER_OUTPUT_SCHEMA: {
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly properties: {
+        readonly proposals: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly properties: {
+                    readonly candidate_id: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly candidate_kind: {
+                        readonly enum: readonly ["schema_must_contain", "text_must_match", "text_must_not_match", "index_must_exist", "ast_pattern", "file_must_not_be_modified", "query_must_filter_by", "route_must_have_guard", "event_must_emit", "service_method_must_call", "human_review_hint"];
+                    };
+                    readonly status: {
+                        readonly enum: readonly ["lift", "demote", "skip"];
+                    };
+                    readonly confidence_signal: {
+                        readonly enum: readonly ["high", "medium", "low"];
+                    };
+                    readonly strict_assertion: {
+                        readonly type: "object";
+                        readonly additionalProperties: true;
+                    };
+                    readonly rationale: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                };
+                readonly required: readonly ["candidate_id", "candidate_kind", "status", "confidence_signal", "rationale"];
+            };
+        };
+    };
+    readonly required: readonly ["proposals"];
+};

package/dist/decision-capture/refinement-schema.js

@@ -0,0 +1,61 @@
+/**
+ * JSON Schema enforced by `claude --json-schema` for the assertion-refiner
+ * proposer output.
+ *
+ * For each input candidate the proposer returns one `RefinementProposal`.
+ * The shape here is intentionally loose on `strict_assertion` — the
+ * production `DecisionAssertion` zod (see `src/ground/schemas.ts`) is the
+ * source of truth and re-validates at apply time. Forcing the discriminated
+ * union into JSON Schema and the proposer's prompt would burn tokens
+ * without buying additional safety, since malformed shapes auto-demote.
+ *
+ * The proposer's per-kind contract is encoded in the system prompt
+ * (`refinement-prompt.ts`), not here.
+ */
+export const REFINEMENT_PROPOSER_OUTPUT_SCHEMA = {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        proposals: {
+            type: "array",
+            items: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    candidate_id: { type: "string", minLength: 1 },
+                    candidate_kind: {
+                        enum: [
+                            "schema_must_contain",
+                            "text_must_match",
+                            "text_must_not_match",
+                            "index_must_exist",
+                            "ast_pattern",
+                            "file_must_not_be_modified",
+                            "query_must_filter_by",
+                            "route_must_have_guard",
+                            "event_must_emit",
+                            "service_method_must_call",
+                            "human_review_hint",
+                        ],
+                    },
+                    status: { enum: ["lift", "demote", "skip"] },
+                    confidence_signal: { enum: ["high", "medium", "low"] },
+                    strict_assertion: {
+                        type: "object",
+                        additionalProperties: true,
+                    },
+                    rationale: { type: "string", minLength: 1 },
+                },
+                required: [
+                    "candidate_id",
+                    "candidate_kind",
+                    "status",
+                    "confidence_signal",
+                    "rationale",
+                ],
+            },
+        },
+    },
+    required: ["proposals"],
+};
+//# sourceMappingURL=refinement-schema.js.map

package/dist/decision-capture/refinement-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"refinement-schema.js","sourceRoot":"","sources":["../../src/decision-capture/refinement-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,iCAAiC,GAAG;IAC/C,IAAI,EAAE,QAAQ;IACd,oBAAoB,EAAE,KAAK;IAC3B,UAAU,EAAE;QACV,SAAS,EAAE;YACT,IAAI,EAAE,OAAO;YACb,KAAK,EAAE;gBACL,IAAI,EAAE,QAAQ;gBACd,oBAAoB,EAAE,KAAK;gBAC3B,UAAU,EAAE;oBACV,YAAY,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC,EAAE;oBAC9C,cAAc,EAAE;wBACd,IAAI,EAAE;4BACJ,qBAAqB;4BACrB,iBAAiB;4BACjB,qBAAqB;4BACrB,kBAAkB;4BAClB,aAAa;4BACb,2BAA2B;4BAC3B,sBAAsB;4BACtB,uBAAuB;4BACvB,iBAAiB;4BACjB,0BAA0B;4BAC1B,mBAAmB;yBACpB;qBACF;oBACD,MAAM,EAAE,EAAE,IAAI,EAAE,CAAC,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,EAAE;oBAC5C,iBAAiB,EAAE,EAAE,IAAI,EAAE,CAAC,MAAM,EAAE,QAAQ,EAAE,KAAK,CAAC,EAAE;oBACtD,gBAAgB,EAAE;wBAChB,IAAI,EAAE,QAAQ;wBACd,oBAAoB,EAAE,IAAI;qBAC3B;oBACD,SAAS,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC,EAAE;iBAC5C;gBACD,QAAQ,EAAE;oBACR,cAAc;oBACd,gBAAgB;oBAChB,QAAQ;oBACR,mBAAmB;oBACnB,WAAW;iBACZ;aACF;SACF;KACF;IACD,QAAQ,EAAE,CAAC,WAAW,CAAC;CACf,CAAC"}

package/dist/decision-capture/refinement.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Phase 14.x — assertion refinement.
+ *
+ * Lifts the loose `candidate_assertions:` set on an accepted decision into
+ * the strict `assertions:` shape that Layer-D sensors enforce.
+ *
+ * Flow:
+ *   read accepted decision file
+ *   → proposeStrictAssertions  (Tier-1 LLM)
+ *   → re-validate each lift via DecisionAssertion zod (auto-demote on fail)
+ *   → adapter.requestDialog: a) approve_all  b) approve_high_only
+ *                            c) demote_all   d) skip
+ *   → liftCandidatesToAssertions writes the file
+ *   → ledger regenerates so the new strict assertions become live
+ *
+ * The proposer runs READ-ONLY. The writer + dialog drive everything that
+ * touches the filesystem. A proposer failure (timeout, malformed JSON,
+ * subprocess crash) does NOT roll back the prior accept — it returns
+ * `proposer_failed: true` and leaves candidates under their loose
+ * `candidate_assertions:` field for the next refine pass.
+ */
+import type { FrontendAdapter } from "../frontend-types.js";
+import type { ClaudeTier } from "../claude/index.js";
+import type { RefinementResult, RefinerInput, RefinerOutput } from "./types.js";
+export interface ProposerResult {
+    output: RefinerOutput;
+    duration_ms: number;
+    usage?: {
+        input_tokens?: number;
+        output_tokens?: number;
+    };
+}
+/**
+ * Single Tier-1 (Haiku default) LLM call producing one proposal per
+ * input candidate. The output is gated by the JSON Schema on the CLI
+ * side and re-validated structurally here.
+ */
+export declare function proposeStrictAssertions(input: RefinerInput): Promise<ProposerResult>;
+export interface RunDecisionRefinementArgs {
+    /** Repo root for the mirror checkout. */
+    repoRoot: string;
+    /** DEC-id of the accepted decision whose candidates we're refining. */
+    decisionId: string;
+    /** Adapter that owns the confirm dialog. */
+    adapter: FrontendAdapter;
+    /** Channel for the dialog (Discord thread / DM). */
+    channelId?: string;
+    /** Tier for the proposer call. Default = haiku. */
+    tier?: ClaudeTier;
+    /** Per-call timeout for the proposer. */
+    proposerTimeoutMs?: number;
+    /** Dialog timeout. Default 60_000 ms. */
+    dialogTimeoutMs?: number;
+    /**
+     * Smokes inject a stub here so they can verify dialog branching without
+     * burning claude quota. Defaults to `proposeStrictAssertions`.
+     */
+    proposerOverride?: typeof proposeStrictAssertions;
+}
+export declare function runDecisionRefinement(args: RunDecisionRefinementArgs): Promise<RefinementResult>;