@meetless/mla 0.1.4

package/dist/lib/activation.js

@@ -0,0 +1,79 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ACTIVATION_FILENAME = void 0;
+exports.findActivation = findActivation;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+// Per-folder activation marker (opt-in capture gate). The bash counterpart
+// lives in hooks-template/common.sh (`meetless_activated`); this module is the
+// TypeScript side used by `mla activate` (write) and `mla doctor` (report).
+// Both sides MUST agree on the filename and the nearest-wins walk-up semantics.
+// "marker" here means the folder activation marker `.meetless.json`; it is the
+// only marker concept in the CLI.
+exports.ACTIVATION_FILENAME = ".meetless.json";
+// Walk UP from startDir looking for the nearest `.meetless.json`, nearest-wins,
+// mirroring how Claude Code resolves CLAUDE.md and how common.sh's
+// `meetless_activated` gate behaves. Returns null when no marker is found.
+function findActivation(startDir) {
+    let dir = path.resolve(startDir);
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const candidate = path.join(dir, exports.ACTIVATION_FILENAME);
+        if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
+            const found = { path: candidate, dir };
+            try {
+                const parsed = JSON.parse(fs.readFileSync(candidate, "utf8"));
+                if (typeof parsed.workspaceId === "string" && parsed.workspaceId) {
+                    found.workspaceId = parsed.workspaceId;
+                }
+                if (typeof parsed.workspaceName === "string" && parsed.workspaceName) {
+                    found.workspaceName = parsed.workspaceName;
+                }
+            }
+            catch (e) {
+                // Matches the bash gate: a malformed marker still activates the folder
+                // (the file exists); the workspaceId is simply treated as absent.
+                found.parseError = e.message;
+            }
+            return found;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}

package/dist/lib/active-conflict-cache.js

@@ -0,0 +1,141 @@
+"use strict";
+// Active cross-session conflict snapshot: the zero-network hand-off between the
+// CLI turn-boundary sync (`_internal steer-sync`, which fetches the session's
+// currently-open conflicts from control on the SAME pass that pulls steers) and
+// the PreToolUse hook (which surfaces a SOFT warning when one is open).
+//
+// G8 / D1, notes/20260626-g8-cross-session-conflict-redesign.md §11.3 (CRITICAL-5).
+// The snapshot is the COMPLETE current open-conflict set, overwritten each turn
+// (never appended), so a resolved conflict simply disappears on the next sync and
+// the warning stops automatically. The hook reads it synchronously with NO network
+// call (same hot-path constraint as the steer cache and the governance nudge).
+//
+// Two deliberate properties:
+//   - The signal source is the refreshed complete snapshot, NEVER steer-injection
+//     state. A steer can be injected once and then the conflict resolves; injection
+//     state is not conflict state (§11.3 / §11.4).
+//   - A snapshot that fails to refresh (sync down) FAILS OPEN: a reader past the TTL
+//     treats it as absent (no warning) rather than a stuck warning. The warning is
+//     soft, so the safe direction on staleness is to say nothing.
+//
+// The file lives beside the steer cache under $MEETLESS_HOME/logs/steer/ because the
+// same turn-boundary pass writes both; the session id is opaque
+// (CLAUDE_CODE_SESSION_ID), used verbatim like the steer cache.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CONFLICT_GATE_MODE = exports.ACTIVE_CONFLICT_TTL_SECONDS = void 0;
+exports.resolveConflictGateMode = resolveConflictGateMode;
+exports.activeConflictCachePath = activeConflictCachePath;
+exports.writeActiveConflictCache = writeActiveConflictCache;
+exports.readActiveConflicts = readActiveConflicts;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("./config");
+// How long a snapshot stays trusted before a reader treats it as stale and fails
+// open. The sync rewrites it every flush (Stop hook, once per turn), so a healthy
+// session refreshes well inside this window; a window this wide only matters when
+// the sync is genuinely down, at which point failing open is the intended safe
+// outcome. Generous on purpose: a single long agent turn must not false-expire a
+// real open conflict.
+exports.ACTIVE_CONFLICT_TTL_SECONDS = 30 * 60;
+/** The shipped default. Soft only: a default-deny that fails closed on a stale
+ * snapshot would brick coding sessions and burn trust (§0.1, the wedge's own
+ * "soft gate before hard gate" non-negotiable). wire.ts re-exports this as the
+ * system default so flipping to hard later is a single wired change, not a rewrite. */
+exports.DEFAULT_CONFLICT_GATE_MODE = "soft";
+/** Resolve the gate mode from the environment, defaulting to soft. An unknown
+ * value degrades to soft (fail-safe): the only behavior that can ever block a tool
+ * is the explicit, opted-in hard mode, which is not enabled now. */
+function resolveConflictGateMode(env = process.env) {
+    return env.MEETLESS_D1_CONFLICT_GATE === "hard" ? "hard" : exports.DEFAULT_CONFLICT_GATE_MODE;
+}
+function activeConflictCachePath(sessionId, home = config_1.HOME) {
+    return path.join(home, "logs", "steer", `active-conflicts-${sessionId}.json`);
+}
+// Best-effort: a failed cache write must never break the steer-sync hop (itself
+// best-effort inside flush.sh). Worst case the hook keeps reading the prior
+// snapshot until it ages past the TTL and fails open.
+function writeActiveConflictCache(sessionId, conflicts, home = config_1.HOME, nowSeconds = Math.floor(Date.now() / 1000)) {
+    try {
+        const file = activeConflictCachePath(sessionId, home);
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.writeFileSync(file, JSON.stringify({ conflicts, ts: nowSeconds }));
+    }
+    catch {
+        /* non-fatal */
+    }
+}
+function coerceConflicts(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    const out = [];
+    for (const item of raw) {
+        if (item &&
+            typeof item === "object" &&
+            typeof item.caseId === "string" &&
+            typeof item.openedAt === "string" &&
+            typeof item.reason === "string") {
+            const c = item;
+            out.push({ caseId: c.caseId, openedAt: c.openedAt, reason: c.reason });
+        }
+    }
+    return out;
+}
+/**
+ * Read the session's open-conflict snapshot for the PreToolUse warning. Returns []
+ * on ANY of: missing file, parse failure, malformed body, or a snapshot older than
+ * `ttlSeconds` (the fail-open staleness guard). [] means "no warning"; a non-empty
+ * result means at least one currently-open conflict. The reader never throws and
+ * never touches the network.
+ */
+function readActiveConflicts(sessionId, opts = {}) {
+    const home = opts.home ?? config_1.HOME;
+    const nowSeconds = opts.nowSeconds ?? Math.floor(Date.now() / 1000);
+    const ttlSeconds = opts.ttlSeconds ?? exports.ACTIVE_CONFLICT_TTL_SECONDS;
+    try {
+        const file = activeConflictCachePath(sessionId, home);
+        const body = JSON.parse(fs.readFileSync(file, "utf8"));
+        // Staleness guard: a snapshot whose ts is missing, non-numeric, or older than
+        // the TTL is treated as absent so a sync-down session fails open.
+        const ts = typeof body.ts === "number" ? body.ts : null;
+        if (ts === null || nowSeconds - ts > ttlSeconds) {
+            return [];
+        }
+        return coerceConflicts(body.conflicts);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/lib/active-memory.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reduceActiveMemory = reduceActiveMemory;
+exports.classifyIngestIntent = classifyIngestIntent;
+// tools/meetless-agent/src/lib/active-memory.ts
+// Zone 1 (Active Review) store reader. The bash PostToolUse hook appends raw
+// records to ~/.meetless/logs/kb-knowledge.jsonl (fast, flock-guarded, no network).
+// All dedup/TTL/debounce/caps live here, applied at READ time, so the hot path
+// stays a single append and the policy is unit-testable in isolation.
+// See notes/20260604-auto-propose-produced-docs-to-kb.md (active-memory store).
+const fs_1 = require("fs");
+const identity_envelope_1 = require("./identity-envelope");
+// Read the append-only log and return the live, deduped, debounced, capped set of
+// Active Review candidates. Ordering: later records win on dedup (debounce keeps
+// the final content of a turn; identical content collapses). Returns at most
+// maxRecords, most recent first by file order.
+function reduceActiveMemory(file, opts) {
+    if (!(0, fs_1.existsSync)(file))
+        return [];
+    const ttlMs = opts.ttlHours * 3600 * 1000;
+    const lines = (0, fs_1.readFileSync)(file, "utf8").split("\n").filter((l) => l.trim().length > 0);
+    // Debounce within a turn: the dedup identity excludes contentHash via a separate
+    // path-key; collapse multiple edits to one canonicalPath in one (session,turn)
+    // down to the final content, then apply content-hash dedup across turns.
+    const turnKeyed = new Map();
+    for (const line of lines) {
+        let r;
+        try {
+            r = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (r.event !== "active_memory_record")
+            continue;
+        if (opts.sessionId !== undefined && r.sessionId !== opts.sessionId)
+            continue; // scope BEFORE dedup
+        const created = Date.parse(r.createdAt);
+        if (Number.isFinite(created) && opts.nowMs - created > ttlMs)
+            continue; // TTL eviction
+        const turnPathKey = [r.workspaceId, r.repoRootHash, r.ownerUserId, r.sessionId, r.turnIndex, r.canonicalPath, r.kind].join("|");
+        turnKeyed.set(turnPathKey, r); // later edit in same turn wins (debounce)
+    }
+    // Content-hash dedup across turns: collapse identical content to one record.
+    const deduped = new Map();
+    for (const r of turnKeyed.values()) {
+        deduped.set((0, identity_envelope_1.dedupIdentity)(r), r); // later occurrence wins
+    }
+    const all = Array.from(deduped.values());
+    if (all.length <= opts.maxRecords)
+        return all;
+    return all.slice(all.length - opts.maxRecords); // keep most recent
+}
+function classifyIngestIntent(text) {
+    const t = text.toLowerCase();
+    if (/\b(ingest|add)\b.*\bkb\b/.test(t) || /\binto (the )?kb\b/.test(t))
+        return "kb_ingest";
+    return "active_only";
+}

package/dist/lib/active-review-runner.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runActiveReview = runActiveReview;
+const conflict_advisory_1 = require("./conflict-advisory");
+async function runActiveReview(args) {
+    if (args.records.length === 0) {
+        return { advisories: [], degraded: false };
+    }
+    try {
+        const resp = await args.intel.detect({ dryRun: true, candidates: args.records });
+        // Defensive: Active Review must be dry-run. A response that claims it
+        // persisted is a contract violation; drop the advisories and degrade rather
+        // than act on detections that may have mutated the graph.
+        if (resp.persisted) {
+            return { advisories: [], degraded: true };
+        }
+        return {
+            advisories: (0, conflict_advisory_1.advisoriesFromDetections)(resp.detections, { minConfidence: args.minConfidence }),
+            degraded: false,
+        };
+    }
+    catch {
+        // advise-never-block (P6): any intel failure is swallowed.
+        return { advisories: [], degraded: true };
+    }
+}

package/dist/lib/agent-decision/index.js

@@ -0,0 +1,25 @@
+"use strict";
+// src/lib/agent-decision/index.ts
+//
+// Barrel for the provider-neutral agent-human decision contract. The canonical
+// types and validator (T1) are the contract; the Claude normalizer (T2+) is the
+// first consumer of it. Spec: notes/20260608-agent-decision-capture-design.md.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./validate"), exports);
+__exportStar(require("./keys"), exports);
+__exportStar(require("./normalize-claude"), exports);

package/dist/lib/agent-decision/keys.js

@@ -0,0 +1,49 @@
+"use strict";
+// src/lib/agent-decision/keys.ts
+//
+// Identity + dedup keys for the canonical agent-decision contract.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildEventKey = buildEventKey;
+exports.buildClaudeProviderEventId = buildClaudeProviderEventId;
+exports.deriveFallbackProviderEventId = deriveFallbackProviderEventId;
+const crypto_1 = require("crypto");
+const types_1 = require("./types");
+// The spool/flush dedup key (spec section 5):
+//   "agent_decision_captured:<provider>:<providerEventId>"
+// Provider-scoped, NOT hardcoded to claude_code, so a second provider's events
+// never collide with Claude's. Control independently upserts on
+// (workspaceId, provider, providerEventId).
+function buildEventKey(provider, providerEventId) {
+    return `${types_1.AGENT_DECISION_EVENT}:${provider}:${providerEventId}`;
+}
+// Claude's stable per-question id (spec section 5): "<tool_use.id>#<questionIndex>".
+function buildClaudeProviderEventId(toolUseId, questionIndex) {
+    return `${toolUseId}#${questionIndex}`;
+}
+// NUL field separator so concatenation is unambiguous: ("a","bc") can never
+// collide with ("ab","c"). NUL cannot appear in JSON text or a session id, so it
+// is a safe fence (a plain space is not, since labels contain spaces).
+const FIELD_SEP = "\u0000";
+// Deterministic fallback providerEventId for a provider with NO stable per-event
+// id (spec section 7, INV-STABLE-FALLBACK-ID):
+//   sha256(provider + providerSessionId + sourceOrdinal
+//          + normalizedPrompt + normalizedChoices + normalizedAnswer)
+// CRITICAL: it must NOT depend on capture timestamp. occurredAt drifts between
+// the real-time path and the transcript-scan backstop, so feeding it in would
+// break dedup across the two paths. It is therefore not an input here. Claude
+// uses the stable "<tool_use.id>#<i>" id and never needs this.
+function deriveFallbackProviderEventId(input) {
+    const normalizedPrompt = JSON.stringify({ title: input.prompt.title, body: input.prompt.body });
+    // Order is significant (positional choice ids), so preserve it.
+    const normalizedChoices = JSON.stringify(input.choices.map((c) => [c.id, c.label, c.description ?? ""]));
+    const normalizedAnswer = JSON.stringify({ type: input.answer.type, value: input.answer.value });
+    const material = [
+        input.provider,
+        input.providerSessionId,
+        input.sourceOrdinal,
+        normalizedPrompt,
+        normalizedChoices,
+        normalizedAnswer,
+    ].join(FIELD_SEP);
+    return (0, crypto_1.createHash)("sha256").update(material, "utf8").digest("hex");
+}

package/dist/lib/agent-decision/normalize-claude.js

@@ -0,0 +1,183 @@
+"use strict";
+// src/lib/agent-decision/normalize-claude.ts
+//
+// The ONE normalization seam, Claude Code AskUserQuestion edition (T2-T5).
+//
+// Pure functions: raw AskUserQuestion (tool_input + tool_response) -> canonical
+// decisions. A single tool call carrying N questions decomposes into N decisions
+// (spec section 5), each with providerEventId "<tool_use.id>#<i>". Everything
+// Claude-specific is confined here and to rawProviderPayload; the output is
+// pure canonical contract (INV-ADAPTER-BOUNDARY, INV-NORMALIZATION).
+//
+// When a real second provider lands, it gets its own normalize-<provider>.ts that
+// emits the same CanonicalDecisionPayload; nothing downstream changes.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLAUDE_TOOL_NAME = exports.CLAUDE_PROVIDER_SOURCE = exports.CLAUDE_PROVIDER = void 0;
+exports.normalizeClaudeAskUserQuestion = normalizeClaudeAskUserQuestion;
+const keys_1 = require("./keys");
+exports.CLAUDE_PROVIDER = "claude_code";
+exports.CLAUDE_PROVIDER_SOURCE = "claude_hook";
+exports.CLAUDE_TOOL_NAME = "AskUserQuestion";
+// Delimiters a multiSelect answer might use IF Claude serializes it as a string.
+// Claude's real multi-select serialization is UNVERIFIED (spec section 3); the
+// adapter tolerates an array (preferred) or any of these delimiters.
+const MULTI_DELIMITERS = /\r?\n|,|\||;/;
+function toChoices(options) {
+    return (options ?? []).map((o, idx) => {
+        const choice = { id: `choice_${idx}`, label: String(o.label ?? "") };
+        if (o.description !== undefined)
+            choice.description = String(o.description);
+        return choice;
+    });
+}
+// Match one answer string against the offered labels. Exact match first
+// (INV-CHOICE-ID resolution, spec section 6).
+function matchLabel(value, choices) {
+    const matches = choices.filter((c) => c.label === value);
+    if (matches.length === 1)
+        return { choiceId: matches[0].id, status: "exact_unique" };
+    if (matches.length > 1)
+        return { choiceId: matches[0].id, status: "exact_ambiguous" };
+    return { status: "no_match" };
+}
+// One leading tolerated delimiter (plus any trailing whitespace) at the start of
+// a string. Used to step past the separator between two offered labels.
+const LEADING_DELIM = /^(?:\r?\n|[,|;])\s*/;
+// A delimited multiSelect string can hide a delimiter INSIDE a label (e.g. an
+// option literally named "Ship now, with a flag"). A naive split would shred that
+// label and silently misreport what the human picked, which is an audit-integrity
+// corruption in a governance product. So first try to read the whole string as a
+// delimiter-joined run of offered labels, longest-label-first; return null (so the
+// caller naive-splits) only when the string is NOT fully explained by offered
+// labels. This also subsumes the whole-string-is-one-label case.
+function matchOfferedLabelSequence(raw, choices) {
+    const labels = choices
+        .map((c) => c.label)
+        .filter((l) => l.length > 0)
+        .sort((a, b) => b.length - a.length);
+    if (labels.length === 0)
+        return null;
+    const found = [];
+    let rest = raw.trim();
+    while (rest.length > 0) {
+        const label = labels.find((l) => rest === l || (rest.startsWith(l) && LEADING_DELIM.test(rest.slice(l.length))));
+        if (label === undefined)
+            return null; // not a clean label run; caller naive-splits
+        found.push(label);
+        rest = rest.slice(label.length).replace(LEADING_DELIM, "").trim();
+    }
+    return found.length > 0 ? found : null;
+}
+// Coerce a raw multiSelect answer into an array of label strings, tolerating
+// either a real array (preferred) or a delimited string.
+function toMultiValues(raw, choices) {
+    if (Array.isArray(raw))
+        return raw.map((x) => String(x));
+    if (typeof raw !== "string")
+        return raw == null ? [] : [String(raw)];
+    // Prefer an exact decomposition into offered labels (handles a label that itself
+    // contains a delimiter); only naive-split when that fails.
+    const asLabels = matchOfferedLabelSequence(raw, choices);
+    if (asLabels)
+        return asLabels;
+    return raw
+        .split(MULTI_DELIMITERS)
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+}
+function buildAnswer(question, rawAnswer, choices) {
+    const multiSelect = question.multiSelect === true;
+    if (multiSelect) {
+        const values = toMultiValues(rawAnswer, choices);
+        const matchedIds = [];
+        let anyMatch = false;
+        let anyAmbiguous = false;
+        for (const v of values) {
+            const m = matchLabel(v, choices);
+            if (m.status === "no_match")
+                continue;
+            anyMatch = true;
+            if (m.status === "exact_ambiguous")
+                anyAmbiguous = true;
+            if (m.choiceId)
+                matchedIds.push(m.choiceId);
+        }
+        const status = !anyMatch ? "no_match" : anyAmbiguous ? "exact_ambiguous" : "exact_unique";
+        const answer = {
+            type: "multi_choice_labels",
+            value: values,
+            choiceMatchStatus: status,
+            raw: rawAnswer,
+        };
+        if (matchedIds.length > 0)
+            answer.choiceIds = matchedIds;
+        return answer;
+    }
+    // Single-select. Claude returns the chosen option label, OR free text the user
+    // typed for "Other". Match by exact label.
+    const value = typeof rawAnswer === "string" ? rawAnswer : String(rawAnswer ?? "");
+    const m = matchLabel(value, choices);
+    if (m.status === "no_match") {
+        return { type: "free_text", value, choiceMatchStatus: "no_match", raw: rawAnswer };
+    }
+    // Known, unfixable limitation (spec section 6): if the user typed "Other" text
+    // that exactly equals an offered label, this records it as a selection. Claude
+    // does not label answer origin, so the adapter cannot tell them apart.
+    return {
+        type: "choice_label",
+        value,
+        choiceId: m.choiceId,
+        choiceMatchStatus: m.status,
+        raw: rawAnswer,
+    };
+}
+function deriveDecisionKind(question, answer) {
+    if (question.multiSelect === true)
+        return "multi_choice";
+    if (answer.type === "free_text")
+        return "free_text";
+    return "choice";
+}
+// Decompose one AskUserQuestion call into N canonical decisions, one per question.
+// Questions with no entry in the answers map are skipped: a question that was not
+// answered is not a captured human decision.
+function normalizeClaudeAskUserQuestion(raw, ctx) {
+    const out = [];
+    const questions = Array.isArray(raw.questions) ? raw.questions : [];
+    questions.forEach((question, i) => {
+        const key = question.question;
+        if (typeof key !== "string")
+            return;
+        if (!(key in (raw.answers ?? {})))
+            return; // unanswered -> not a decision
+        const rawAnswer = raw.answers[key];
+        const choices = toChoices(question.options);
+        const answer = buildAnswer(question, rawAnswer, choices);
+        const decisionKind = deriveDecisionKind(question, answer);
+        const payload = {
+            provider: exports.CLAUDE_PROVIDER,
+            providerSource: exports.CLAUDE_PROVIDER_SOURCE,
+            providerToolName: exports.CLAUDE_TOOL_NAME,
+            providerEventId: (0, keys_1.buildClaudeProviderEventId)(raw.toolUseId, i),
+            providerSessionId: ctx.providerSessionId,
+            decisionKind,
+            prompt: {
+                title: typeof question.header === "string" && question.header.trim().length > 0 ? question.header : key,
+                body: key,
+            },
+            choices,
+            answer,
+            multiSelect: question.multiSelect === true,
+            turnIndex: ctx.turnIndex ?? null,
+            traceId: ctx.traceId ?? null,
+            capturedBy: ctx.capturedBy,
+            actorDisplayName: ctx.actorDisplayName ?? null,
+            // Audit: preserve exactly what the provider gave us for this question.
+            rawProviderPayload: { question, answer: rawAnswer },
+        };
+        if (ctx.occurredAt !== undefined)
+            payload.occurredAt = ctx.occurredAt;
+        out.push(payload);
+    });
+    return out;
+}

package/dist/lib/agent-decision/types.js

@@ -0,0 +1,21 @@
+"use strict";
+// src/lib/agent-decision/types.ts
+//
+// The provider-neutral canonical contract for agent-human decision capture.
+// This is the ONE source the rest of the pipeline conforms to (spec
+// notes/20260608-agent-decision-capture-design.md, sections 6 and 7).
+//
+// The domain primitive is an "agent-human decision": the agent asked a human to
+// steer, the human answered. Claude Code's AskUserQuestion is the first (and for
+// now only) producer behind the normalize() seam. NOTHING in these types names a
+// Claude tool concept as a canonical field; provider specifics live only in the
+// explicitly provider-scoped fields and in rawProviderPayload (INV-ADAPTER-BOUNDARY).
+//
+// Control mirrors this contract as a class-validator DTO. The CLI cannot import
+// across the nested-workspace boundary into apps/control, so the two definitions
+// are kept in sync by the contract tests on both sides plus the synthetic
+// non-Claude ingest test (INV-CLAUDE-FIRST-NOT-ONLY). The spec is the source of
+// truth for both.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGENT_DECISION_EVENT = void 0;
+exports.AGENT_DECISION_EVENT = "agent_decision_captured";