@manehorizons/cadence-core 1.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Thomas Powers
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,5 @@
+# @manehorizons/cadence-core
+
+The CADENCE CLI engine — the `cadence` command (draft → build → settle loop, gates, telemetry).
+
+Part of the [CADENCE](https://github.com/manehorizons/cadence) monorepo. MIT licensed.

package/bin/cadence.cjs

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+require('node:child_process')
+  .spawn(process.execPath, [require('node:path').join(__dirname, '..', 'dist', 'cli', 'index.js'), ...process.argv.slice(2)], { stdio: 'inherit' })
+  .on('exit', (code) => process.exit(code ?? 0));

package/dist/build/record.d.ts

@@ -0,0 +1,16 @@
+import type { TaskStatus } from '@manehorizons/cadence-types';
+export type RecordableStatus = Exclude<TaskStatus, 'PENDING' | 'IN_PROGRESS'>;
+/**
+ * Phase 24.2 — per-task verifier verdict attached to a task row when
+ * the `'per-task-verify'` gate fires. `bypassed` is true when the user
+ * passed `--allow-per-task-failure` to record a `refuse` verdict anyway.
+ */
+export interface PerTaskVerifyRecord {
+    verdict: 'pass' | 'concerns' | 'refuse';
+    reason: string;
+    provider: string;
+    model?: string;
+    bypassed?: boolean;
+}
+export declare function recordTaskOutcome(cwd: string, taskId: string, status: RecordableStatus, notes: string, perTaskVerify?: PerTaskVerifyRecord): Promise<void>;
+//# sourceMappingURL=record.d.ts.map

package/dist/build/record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"record.d.ts","sourceRoot":"","sources":["../../src/build/record.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAK9D,MAAM,MAAM,gBAAgB,GAAG,OAAO,CAAC,UAAU,EAAE,SAAS,GAAG,aAAa,CAAC,CAAC;AAE9E;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,MAAM,GAAG,UAAU,GAAG,QAAQ,CAAC;IACxC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAgBD,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,gBAAgB,EACxB,KAAK,EAAE,MAAM,EACb,aAAa,CAAC,EAAE,mBAAmB,GAClC,OAAO,CAAC,IAAI,CAAC,CAgCf"}

package/dist/build/record.js

@@ -0,0 +1,33 @@
+import { join } from 'node:path';
+import { readFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { SimpleStateBackend } from '../state/simple.js';
+import { atomicWriteJSON } from '../state/atomic-write.js';
+import { LoopViolationError } from '../errors.js';
+export async function recordTaskOutcome(cwd, taskId, status, notes, perTaskVerify) {
+    const backend = new SimpleStateBackend(cwd);
+    const state = await backend.readState();
+    if (state.loopPosition !== 'BUILD' || !state.activeDraft || !state.activePhase) {
+        throw new LoopViolationError('task outcome can only be recorded while loopPosition=BUILD with an active draft', { expected: 'BUILD', actual: state.loopPosition });
+    }
+    const progPath = join(cwd, '.cadence/phases', state.activePhase, `${state.activeDraft}-PROGRESS.json`);
+    let progress;
+    if (existsSync(progPath)) {
+        progress = JSON.parse(await readFile(progPath, 'utf8'));
+    }
+    else {
+        progress = { draftId: state.activeDraft, tasks: {} };
+    }
+    progress.tasks[taskId] = {
+        status,
+        notes,
+        touchedFiles: state.activeTask?.touchedFiles ?? [],
+        updatedAt: new Date().toISOString(),
+        ...(perTaskVerify ? { perTaskVerify } : {}),
+    };
+    await atomicWriteJSON(progPath, progress);
+    state.activeTask = { id: taskId, status, touchedFiles: [] };
+    // Phase 41.1 — commit() also refreshes STATE.md (was stale after build task).
+    await backend.commit(state);
+}
+//# sourceMappingURL=record.js.map

package/dist/build/record.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"record.js","sourceRoot":"","sources":["../../src/build/record.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAErC,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AA+BlD,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,GAAW,EACX,MAAc,EACd,MAAwB,EACxB,KAAa,EACb,aAAmC;IAEnC,MAAM,OAAO,GAAG,IAAI,kBAAkB,CAAC,GAAG,CAAC,CAAC;IAC5C,MAAM,KAAK,GAAG,MAAM,OAAO,CAAC,SAAS,EAAE,CAAC;IACxC,IAAI,KAAK,CAAC,YAAY,KAAK,OAAO,IAAI,CAAC,KAAK,CAAC,WAAW,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC;QAC/E,MAAM,IAAI,kBAAkB,CAC1B,iFAAiF,EACjF,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,YAAY,EAAE,CAClD,CAAC;IACJ,CAAC;IACD,MAAM,QAAQ,GAAG,IAAI,CACnB,GAAG,EACH,iBAAiB,EACjB,KAAK,CAAC,WAAW,EACjB,GAAG,KAAK,CAAC,WAAW,gBAAgB,CACrC,CAAC;IACF,IAAI,QAAsB,CAAC;IAC3B,IAAI,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;QACzB,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAiB,CAAC;IAC1E,CAAC;SAAM,CAAC;QACN,QAAQ,GAAG,EAAE,OAAO,EAAE,KAAK,CAAC,WAAW,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC;IACvD,CAAC;IACD,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG;QACvB,MAAM;QACN,KAAK;QACL,YAAY,EAAE,KAAK,CAAC,UAAU,EAAE,YAAY,IAAI,EAAE;QAClD,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;QACnC,GAAG,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KAC5C,CAAC;IACF,MAAM,eAAe,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;IAC1C,KAAK,CAAC,UAAU,GAAG,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,EAAE,EAAE,CAAC;IAC5D,8EAA8E;IAC9E,MAAM,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AAC9B,CAAC"}

package/dist/checks/boundary.d.ts

@@ -0,0 +1,35 @@
+import type { AnomalyEvent } from '@manehorizons/cadence-types';
+/** The single line both emission points use for a stray file. */
+export declare const boundaryMessage: (file: string) => string;
+export interface BoundaryCheckInput {
+    /** The allow-set: every file declared across all task `files:` lists. */
+    declaredFiles: Iterable<string>;
+    /**
+     * Candidate files to test against the boundary. Iterated as-given — the
+     * caller owns dedup/order: the PreToolEdit hook passes raw `ctx.raw.files`
+     * (keeps order + dups); settle passes a deduped `Set` of touched files.
+     */
+    touchedFiles: Iterable<string>;
+    /**
+     * Stamps each event's `ts`. The hook precomputes one ISO string and returns
+     * it for every event; settle stamps per-event from its injectable clock.
+     */
+    stamp: () => string;
+    /**
+     * Merged into each event's `context` AFTER the `file` key (e.g. the hook's
+     * `{ source: 'hook.preToolEdit' }`; settle supplies none).
+     */
+    extraContext?: Record<string, unknown>;
+}
+/**
+ * Phase 43.1 — the single home for files-outside-boundary detection. One rule
+ * ("a touched file not in the union of task `files:` is an outsider"), two
+ * emission points: the PreToolEdit hook (`hooks/handlers.ts`) and settle's
+ * `collectAnomalies` (`notify/collect.ts`). Pure — no I/O. Each outsider yields
+ * one `warn` `files-outside-boundary` event; emission (gate membership, notify,
+ * stderr-degrade) stays at each call site. NOT a `Gate` enum member — it is a
+ * hook-time + settle-time anomaly check, so it lives in `checks/` alongside
+ * skill-audit (39.6), OUTSIDE the Phase 44.1 registry.
+ */
+export declare function runBoundaryCheck(input: BoundaryCheckInput): AnomalyEvent[];
+//# sourceMappingURL=boundary.d.ts.map

package/dist/checks/boundary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boundary.d.ts","sourceRoot":"","sources":["../../src/checks/boundary.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE,iEAAiE;AACjE,eAAO,MAAM,eAAe,GAAI,MAAM,MAAM,KAAG,MACU,CAAC;AAE1D,MAAM,WAAW,kBAAkB;IACjC,yEAAyE;IACzE,aAAa,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAChC;;;;OAIG;IACH,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAC/B;;;OAGG;IACH,KAAK,EAAE,MAAM,MAAM,CAAC;IACpB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACxC;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,kBAAkB,GAAG,YAAY,EAAE,CAc1E"}

package/dist/checks/boundary.js

@@ -0,0 +1,29 @@
+/** The single line both emission points use for a stray file. */
+export const boundaryMessage = (file) => `${file} touched but not declared in any task's files:`;
+/**
+ * Phase 43.1 — the single home for files-outside-boundary detection. One rule
+ * ("a touched file not in the union of task `files:` is an outsider"), two
+ * emission points: the PreToolEdit hook (`hooks/handlers.ts`) and settle's
+ * `collectAnomalies` (`notify/collect.ts`). Pure — no I/O. Each outsider yields
+ * one `warn` `files-outside-boundary` event; emission (gate membership, notify,
+ * stderr-degrade) stays at each call site. NOT a `Gate` enum member — it is a
+ * hook-time + settle-time anomaly check, so it lives in `checks/` alongside
+ * skill-audit (39.6), OUTSIDE the Phase 44.1 registry.
+ */
+export function runBoundaryCheck(input) {
+    const declared = new Set(input.declaredFiles);
+    const events = [];
+    for (const file of input.touchedFiles) {
+        if (declared.has(file))
+            continue;
+        events.push({
+            type: 'files-outside-boundary',
+            severity: 'warn',
+            message: boundaryMessage(file),
+            context: { file, ...input.extraContext },
+            ts: input.stamp(),
+        });
+    }
+    return events;
+}
+//# sourceMappingURL=boundary.js.map

package/dist/checks/boundary.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"boundary.js","sourceRoot":"","sources":["../../src/checks/boundary.ts"],"names":[],"mappings":"AAEA,iEAAiE;AACjE,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,IAAY,EAAU,EAAE,CACtD,GAAG,IAAI,gDAAgD,CAAC;AAuB1D;;;;;;;;;GASG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAyB;IACxD,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;IAC9C,MAAM,MAAM,GAAmB,EAAE,CAAC;IAClC,KAAK,MAAM,IAAI,IAAI,KAAK,CAAC,YAAY,EAAE,CAAC;QACtC,IAAI,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC;YAAE,SAAS;QACjC,MAAM,CAAC,IAAI,CAAC;YACV,IAAI,EAAE,wBAAwB;YAC9B,QAAQ,EAAE,MAAM;YAChB,OAAO,EAAE,eAAe,CAAC,IAAI,CAAC;YAC9B,OAAO,EAAE,EAAE,IAAI,EAAE,GAAG,KAAK,CAAC,YAAY,EAAE;YACxC,EAAE,EAAE,KAAK,CAAC,KAAK,EAAE;SAClB,CAAC,CAAC;IACL,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/checks/skill-audit.d.ts

@@ -0,0 +1,29 @@
+import type { SettleContext } from '../gates/types.js';
+/**
+ * Result of the required-skill enforcement check. NOT a `GateResult`: it carries
+ * `effectiveRequired` so the settle adapter can record it on
+ * `state.skillAudit.required` (outside the `summaryPatch` contract), which is why
+ * this check is intentionally not a `GateImpl`.
+ */
+export interface SkillAuditResult {
+    readonly outcome: 'pass' | 'refuse';
+    /** config.skillAudit.required ∪ DRAFT requiredSkills, deduped, order-preserved.
+     *  settle records it on state.skillAudit.required on every non-refuse path. */
+    readonly effectiveRequired: string[];
+}
+/**
+ * Required-skill enforcement check (Phase 34.1 — ROADMAP 23.4). Extracted from
+ * settle.ts verbatim (Phase 39.6). NOT a `Gate` enum member — declaring required
+ * skills IS the opt-in, so it is an anomaly check, not a profile×tier gate. Lives
+ * in `checks/` and is dispatched EXPLICITLY by settle, OUTSIDE the Phase 44.1
+ * registry. It reuses `SettleContext` and reaches the notifier only through
+ * `ctx.emit.skillAuditMiss`.
+ *
+ * `config` is `… | null` (null when loadConfig failed). Deliberate null-config
+ * behavior: still compute + return the effective required set (so SUMMARY stays
+ * truthful) but SKIP enforcement — cannot read telemetry reliably; never
+ * false-refuse on a degraded-config path. The `skill-audit-miss` anomaly is
+ * UNCONDITIONAL (not under the `anomaly-notify` guard).
+ */
+export declare const runSkillAuditCheck: (ctx: SettleContext) => Promise<SkillAuditResult>;
+//# sourceMappingURL=skill-audit.d.ts.map

package/dist/checks/skill-audit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill-audit.d.ts","sourceRoot":"","sources":["../../src/checks/skill-audit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAGvD;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,QAAQ,CAAC;IACpC;mFAC+E;IAC/E,QAAQ,CAAC,iBAAiB,EAAE,MAAM,EAAE,CAAC;CACtC;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,kBAAkB,GAC7B,KAAK,aAAa,KACjB,OAAO,CAAC,gBAAgB,CA2C1B,CAAC"}

package/dist/checks/skill-audit.js

@@ -0,0 +1,57 @@
+import { missingSkills } from '../verify/skill-match.js';
+/**
+ * Required-skill enforcement check (Phase 34.1 — ROADMAP 23.4). Extracted from
+ * settle.ts verbatim (Phase 39.6). NOT a `Gate` enum member — declaring required
+ * skills IS the opt-in, so it is an anomaly check, not a profile×tier gate. Lives
+ * in `checks/` and is dispatched EXPLICITLY by settle, OUTSIDE the Phase 44.1
+ * registry. It reuses `SettleContext` and reaches the notifier only through
+ * `ctx.emit.skillAuditMiss`.
+ *
+ * `config` is `… | null` (null when loadConfig failed). Deliberate null-config
+ * behavior: still compute + return the effective required set (so SUMMARY stays
+ * truthful) but SKIP enforcement — cannot read telemetry reliably; never
+ * false-refuse on a degraded-config path. The `skill-audit-miss` anomaly is
+ * UNCONDITIONAL (not under the `anomaly-notify` guard).
+ */
+export const runSkillAuditCheck = async (ctx) => {
+    const config = ctx.config;
+    const effectiveRequired = [
+        ...new Set([
+            ...(config?.skillAudit?.required ?? []),
+            ...(ctx.draft.requiredSkills ?? []),
+        ]),
+    ];
+    if (effectiveRequired.length > 0 && config) {
+        const invoked = ctx.state.skillAudit.invoked;
+        if (!config.telemetry.skillInvocations) {
+            await ctx.emit.skillAuditMiss({
+                required: effectiveRequired,
+                invoked,
+                missing: effectiveRequired,
+                severity: 'warn',
+                unenforceable: true,
+            });
+        }
+        else {
+            const missing = missingSkills(effectiveRequired, invoked);
+            if (missing.length > 0) {
+                const bypass = ctx.opts.allowSkillAuditMiss === true;
+                await ctx.emit.skillAuditMiss({
+                    required: effectiveRequired,
+                    invoked,
+                    missing,
+                    severity: bypass ? 'warn' : 'error',
+                    ...(bypass ? { bypassed: true } : {}),
+                });
+                if (!bypass) {
+                    ctx.io.err(`settle run refused: required skill(s) not invoked: ${missing.join(', ')}. ` +
+                        `Invoke them, or pass --allow-skill-audit-miss to override.\n`);
+                    return { outcome: 'refuse', effectiveRequired };
+                }
+                ctx.io.err(`skill-audit: --allow-skill-audit-miss set; proceeding past ${missing.length} missing skill(s).\n`);
+            }
+        }
+    }
+    return { outcome: 'pass', effectiveRequired };
+};
+//# sourceMappingURL=skill-audit.js.map

package/dist/checks/skill-audit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill-audit.js","sourceRoot":"","sources":["../../src/checks/skill-audit.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAezD;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,KAAK,EACrC,GAAkB,EACS,EAAE;IAC7B,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC;IAC1B,MAAM,iBAAiB,GAAG;QACxB,GAAG,IAAI,GAAG,CAAC;YACT,GAAG,CAAC,MAAM,EAAE,UAAU,EAAE,QAAQ,IAAI,EAAE,CAAC;YACvC,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC,cAAc,IAAI,EAAE,CAAC;SACpC,CAAC;KACH,CAAC;IACF,IAAI,iBAAiB,CAAC,MAAM,GAAG,CAAC,IAAI,MAAM,EAAE,CAAC;QAC3C,MAAM,OAAO,GAAG,GAAG,CAAC,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC;QAC7C,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,gBAAgB,EAAE,CAAC;YACvC,MAAM,GAAG,CAAC,IAAI,CAAC,cAAc,CAAC;gBAC5B,QAAQ,EAAE,iBAAiB;gBAC3B,OAAO;gBACP,OAAO,EAAE,iBAAiB;gBAC1B,QAAQ,EAAE,MAAM;gBAChB,aAAa,EAAE,IAAI;aACpB,CAAC,CAAC;QACL,CAAC;aAAM,CAAC;YACN,MAAM,OAAO,GAAG,aAAa,CAAC,iBAAiB,EAAE,OAAO,CAAC,CAAC;YAC1D,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACvB,MAAM,MAAM,GAAG,GAAG,CAAC,IAAI,CAAC,mBAAmB,KAAK,IAAI,CAAC;gBACrD,MAAM,GAAG,CAAC,IAAI,CAAC,cAAc,CAAC;oBAC5B,QAAQ,EAAE,iBAAiB;oBAC3B,OAAO;oBACP,OAAO;oBACP,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO;oBACnC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;iBACtC,CAAC,CAAC;gBACH,IAAI,CAAC,MAAM,EAAE,CAAC;oBACZ,GAAG,CAAC,EAAE,CAAC,GAAG,CACR,sDAAsD,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI;wBAC1E,8DAA8D,CACjE,CAAC;oBACF,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,CAAC;gBAClD,CAAC;gBACD,GAAG,CAAC,EAAE,CAAC,GAAG,CACR,8DAA8D,OAAO,CAAC,MAAM,sBAAsB,CACnG,CAAC;YACJ,CAAC;QACH,CAAC;IACH,CAAC;IACD,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,CAAC;AAChD,CAAC,CAAC"}

package/dist/classify/tier.d.ts

@@ -0,0 +1,9 @@
+import type { Tier, CadenceConfig } from '@manehorizons/cadence-types';
+export interface DraftSignals {
+    tasks: {
+        files: string[];
+    }[];
+    acceptanceCriteria: unknown[];
+}
+export declare function classifyTier(d: DraftSignals, tierConfig: CadenceConfig['tier']): Tier;
+//# sourceMappingURL=tier.d.ts.map

package/dist/classify/tier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tier.d.ts","sourceRoot":"","sources":["../../src/classify/tier.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAEvE,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE;QAAE,KAAK,EAAE,MAAM,EAAE,CAAA;KAAE,EAAE,CAAC;IAC7B,kBAAkB,EAAE,OAAO,EAAE,CAAC;CAC/B;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,YAAY,EAAE,UAAU,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,IAAI,CAkBrF"}

package/dist/classify/tier.js

@@ -0,0 +1,15 @@
+export function classifyTier(d, tierConfig) {
+    const taskCount = d.tasks.length;
+    const fileCount = new Set(d.tasks.flatMap((t) => t.files)).size;
+    if (taskCount <= tierConfig.quickFix.maxTasks &&
+        fileCount <= tierConfig.quickFix.maxFiles) {
+        return 'quick-fix';
+    }
+    if (taskCount <= tierConfig.standard.maxTasks &&
+        fileCount <= tierConfig.standard.maxFiles &&
+        taskCount < tierConfig.complex.minTasks) {
+        return 'standard';
+    }
+    return 'complex';
+}
+//# sourceMappingURL=tier.js.map

package/dist/classify/tier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tier.js","sourceRoot":"","sources":["../../src/classify/tier.ts"],"names":[],"mappings":"AAOA,MAAM,UAAU,YAAY,CAAC,CAAe,EAAE,UAAiC;IAC7E,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC;IACjC,MAAM,SAAS,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;IAEhE,IACE,SAAS,IAAI,UAAU,CAAC,QAAQ,CAAC,QAAQ;QACzC,SAAS,IAAI,UAAU,CAAC,QAAQ,CAAC,QAAQ,EACzC,CAAC;QACD,OAAO,WAAW,CAAC;IACrB,CAAC;IACD,IACE,SAAS,IAAI,UAAU,CAAC,QAAQ,CAAC,QAAQ;QACzC,SAAS,IAAI,UAAU,CAAC,QAAQ,CAAC,QAAQ;QACzC,SAAS,GAAG,UAAU,CAAC,OAAO,CAAC,QAAQ,EACvC,CAAC;QACD,OAAO,UAAU,CAAC;IACpB,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC"}

package/dist/cli/commands/assumption.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from 'commander';
+export declare function registerAssumptionCommand(program: Command): void;
+//# sourceMappingURL=assumption.d.ts.map

package/dist/cli/commands/assumption.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assumption.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/assumption.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAyFzC,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAgRhE"}

package/dist/cli/commands/assumption.js

@@ -0,0 +1,313 @@
+import { AssumptionZ } from '@manehorizons/cadence-types';
+import { addAssumption, readAssumptionLedger, readRecommendationLedger, runAssumptionTransition, } from '../../intelligence/store.js';
+import { renderAssumptionDetail } from '../../intelligence/render-assumption-detail.js';
+function parseSortBy(raw) {
+    if (raw.length === 0)
+        return { error: '--sort-by requires a key' };
+    const colon = raw.indexOf(':');
+    if (colon === -1)
+        return { key: raw, dir: 'asc' };
+    const key = raw.slice(0, colon);
+    const dirRaw = raw.slice(colon + 1);
+    if (key.length === 0)
+        return { error: '--sort-by requires a key' };
+    if (dirRaw !== 'asc' && dirRaw !== 'desc') {
+        return { error: `invalid sort direction: '${dirRaw}' (use 'asc' or 'desc')` };
+    }
+    return { key, dir: dirRaw };
+}
+const ALLOWED_REGEX_FLAGS = new Set(['i', 'm', 's', 'u']);
+function parseRegexFlags(raw) {
+    if (raw.length === 0)
+        return { error: '--filter-regex-flags requires a non-empty value' };
+    const seen = new Set();
+    for (const ch of raw) {
+        if (!ALLOWED_REGEX_FLAGS.has(ch)) {
+            return { error: `invalid flag letter: '${ch}' (allowed: i, m, s, u)` };
+        }
+        if (seen.has(ch)) {
+            return { error: `duplicate flag letter: '${ch}'` };
+        }
+        seen.add(ch);
+    }
+    return { flags: raw };
+}
+const ASN_SORT_KEYS = new Set(['created', 'status', 'text', 'rec']);
+const ASN_STATUS_ORDER = [
+    'open',
+    'validated',
+    'rejected',
+];
+function compareAsn(a, b, key) {
+    switch (key) {
+        case 'created':
+            return a.createdAt < b.createdAt ? -1 : a.createdAt > b.createdAt ? 1 : 0;
+        case 'text':
+            return a.text < b.text ? -1 : a.text > b.text ? 1 : 0;
+        case 'rec':
+            return a.recommendationId < b.recommendationId
+                ? -1
+                : a.recommendationId > b.recommendationId
+                    ? 1
+                    : 0;
+        case 'status':
+            return ASN_STATUS_ORDER.indexOf(a.status) - ASN_STATUS_ORDER.indexOf(b.status);
+        default:
+            return 0;
+    }
+}
+const ASSUMPTION_TRANSITION_DESCRIPTIONS = {
+    validate: 'Mark an open assumption validated',
+    reject: 'Mark an open assumption rejected',
+    reopen: 'Reopen a validated or rejected assumption',
+};
+const ASSUMPTION_TRANSITION_PAST = {
+    validate: 'validated',
+    reject: 'rejected',
+    reopen: 'open',
+};
+export function registerAssumptionCommand(program) {
+    const cmd = program
+        .command('assumption')
+        .description('Manage CADENCE strategic-intelligence assumptions');
+    cmd
+        .command('add')
+        .description('Add a manual assumption tied to a recommendation')
+        .requiredOption('--rec <id>', 'Recommendation id this assumption belongs to')
+        .requiredOption('--text <text>', 'Assumption statement')
+        .action(async (opts) => {
+        try {
+            const a = await addAssumption(process.cwd(), {
+                recommendationId: opts.rec,
+                text: opts.text,
+            });
+            process.stdout.write(`Added ${a.id}: ${a.text}\n`);
+            process.stdout.write(`Next: cadence assumption list\n`);
+        }
+        catch (err) {
+            process.stderr.write(`assumption add failed: ${err instanceof Error ? err.message : String(err)}\n`);
+            process.exitCode = 1;
+        }
+    });
+    cmd
+        .command('show <id>')
+        .description('Show a single assumption with its tied recommendation cross-ref')
+        .option('--format <format>', 'Output format: terminal | json', 'terminal')
+        .action(async (id, opts) => {
+        try {
+            const format = opts.format ?? 'terminal';
+            if (format !== 'terminal' && format !== 'json') {
+                process.stderr.write(`assumption show failed: unsupported format: ${format}\n`);
+                process.exitCode = 1;
+                return;
+            }
+            const asLedger = await readAssumptionLedger(process.cwd());
+            const as = asLedger.assumptions.find((a) => a.id === id);
+            if (!as) {
+                process.stderr.write(`assumption ${id} not found\n`);
+                process.exitCode = 1;
+                return;
+            }
+            const recLedger = await readRecommendationLedger(process.cwd());
+            const rec = recLedger.recommendations.find((r) => r.id === as.recommendationId);
+            if (format === 'json') {
+                const envelope = { assumption: as, recommendation: rec ?? null };
+                process.stdout.write(JSON.stringify(envelope, null, 2) + '\n');
+                return;
+            }
+            const md = renderAssumptionDetail(as, rec);
+            process.stdout.write(md);
+            if (!md.endsWith('\n'))
+                process.stdout.write('\n');
+        }
+        catch (err) {
+            process.stderr.write(`assumption show failed: ${err instanceof Error ? err.message : String(err)}\n`);
+            process.exitCode = 1;
+        }
+    });
+    cmd
+        .command('list')
+        .description('List recorded assumptions')
+        .option('--format <format>', 'Output format: terminal | json', 'terminal')
+        .option('--filter-status <status>', 'Filter to only entries with this status')
+        .option('--filter-rec <recId>', 'Filter to only entries tied to this recommendation')
+        .option('--filter-text <substr>', 'Case-insensitive substring search on text. Mutually exclusive with --filter-text-exact and --filter-regex.')
+        .option('--filter-text-exact <str>', 'Case-insensitive whole-field equality match on text. Mutually exclusive with --filter-text and --filter-regex.')
+        .option('--filter-regex <pattern>', 'Power-user regex filter on text (always case-sensitive by default; use --filter-regex-flags for case-insensitive/multiline/dotAll, or character classes like [Cc]ycle for one-off case-insensitivity). Mutually exclusive with --filter-text and --filter-text-exact.')
+        .option('--filter-regex-flags <flags>', 'RegExp flag letters to apply to --filter-regex. Allowed: i (case-insensitive), m (multiline ^/$), s (dotAll .), u (unicode). Requires --filter-regex.')
+        .option('--sort-by <key>', 'Sort by a single key, optionally with :desc suffix. Allowed keys: created, status, text, rec.')
+        .option('--reverse', 'Reverse the entry order (after filters, before offset/limit)')
+        .option('--offset <n>', 'Skip the first N entries (after filters)')
+        .option('--limit <n>', 'Cap output to first N entries (after filters)')
+        .action(async (opts) => {
+        try {
+            const format = opts.format ?? 'terminal';
+            if (format !== 'terminal' && format !== 'json') {
+                process.stderr.write(`assumption list failed: unsupported format: ${format}\n`);
+                process.exitCode = 1;
+                return;
+            }
+            const ledger = await readAssumptionLedger(process.cwd());
+            let entries = ledger.assumptions;
+            if (opts.filterStatus !== undefined) {
+                const parsed = AssumptionZ.shape.status.safeParse(opts.filterStatus);
+                if (!parsed.success) {
+                    process.stderr.write(`assumption list failed: invalid status: ${opts.filterStatus}\n`);
+                    process.exitCode = 1;
+                    return;
+                }
+                entries = entries.filter((a) => a.status === parsed.data);
+            }
+            if (opts.filterRec !== undefined) {
+                entries = entries.filter((a) => a.recommendationId === opts.filterRec);
+            }
+            if (opts.filterTextExact === '') {
+                process.stderr.write(`assumption list failed: --filter-text-exact requires a non-empty value\n`);
+                process.exitCode = 1;
+                return;
+            }
+            if (opts.filterTextExact !== undefined && opts.filterText !== undefined) {
+                process.stderr.write(`assumption list failed: cannot combine --filter-text-exact with --filter-text\n`);
+                process.exitCode = 1;
+                return;
+            }
+            if (opts.filterTextExact !== undefined && opts.filterRegex !== undefined) {
+                process.stderr.write(`assumption list failed: cannot combine --filter-text-exact with --filter-regex\n`);
+                process.exitCode = 1;
+                return;
+            }
+            if (opts.filterText !== undefined && opts.filterRegex !== undefined) {
+                process.stderr.write(`assumption list failed: cannot combine --filter-text and --filter-regex\n`);
+                process.exitCode = 1;
+                return;
+            }
+            if (opts.filterText !== undefined) {
+                const needle = opts.filterText.toLowerCase();
+                entries = entries.filter((a) => a.text.toLowerCase().includes(needle));
+            }
+            if (opts.filterRegexFlags !== undefined && opts.filterRegex === undefined) {
+                process.stderr.write(`assumption list failed: --filter-regex-flags requires --filter-regex to also be set\n`);
+                process.exitCode = 1;
+                return;
+            }
+            let regexFlags;
+            if (opts.filterRegexFlags !== undefined) {
+                const parsed = parseRegexFlags(opts.filterRegexFlags);
+                if ('error' in parsed) {
+                    process.stderr.write(`assumption list failed: ${parsed.error}\n`);
+                    process.exitCode = 1;
+                    return;
+                }
+                regexFlags = parsed.flags;
+            }
+            if (opts.filterRegex !== undefined) {
+                let regex;
+                try {
+                    regex = new RegExp(opts.filterRegex, regexFlags);
+                }
+                catch (err) {
+                    process.stderr.write(`assumption list failed: invalid regex: ${err instanceof Error ? err.message : String(err)}\n`);
+                    process.exitCode = 1;
+                    return;
+                }
+                entries = entries.filter((a) => regex.test(a.text));
+            }
+            if (opts.filterTextExact !== undefined) {
+                const needle = opts.filterTextExact.toLowerCase();
+                entries = entries.filter((a) => a.text.toLowerCase() === needle);
+            }
+            if (opts.sortBy !== undefined) {
+                const parsed = parseSortBy(opts.sortBy);
+                if ('error' in parsed) {
+                    process.stderr.write(`assumption list failed: ${parsed.error}\n`);
+                    process.exitCode = 1;
+                    return;
+                }
+                if (!ASN_SORT_KEYS.has(parsed.key)) {
+                    const allowed = [...ASN_SORT_KEYS].join(', ');
+                    process.stderr.write(`assumption list failed: invalid sort key: ${parsed.key} (allowed: ${allowed})\n`);
+                    process.exitCode = 1;
+                    return;
+                }
+                const sortKey = parsed.key;
+                const dir = parsed.dir;
+                entries = entries.slice().sort((a, b) => dir === 'desc' ? -compareAsn(a, b, sortKey) : compareAsn(a, b, sortKey));
+            }
+            if (opts.reverse) {
+                entries = entries.slice().reverse();
+            }
+            if (opts.offset !== undefined) {
+                const n = Number(opts.offset);
+                if (!Number.isInteger(n) || n < 0) {
+                    process.stderr.write(`assumption list failed: invalid offset: ${opts.offset}\n`);
+                    process.exitCode = 1;
+                    return;
+                }
+                entries = entries.slice(n);
+            }
+            if (opts.limit !== undefined) {
+                const n = Number(opts.limit);
+                if (!Number.isInteger(n) || n < 1) {
+                    process.stderr.write(`assumption list failed: invalid limit: ${opts.limit}\n`);
+                    process.exitCode = 1;
+                    return;
+                }
+                entries = entries.slice(0, n);
+            }
+            if (format === 'json') {
+                process.stdout.write(JSON.stringify(entries, null, 2) + '\n');
+                return;
+            }
+            if (entries.length === 0) {
+                const filterDims = [];
+                if (opts.filterStatus)
+                    filterDims.push(`status=${opts.filterStatus}`);
+                if (opts.filterRec)
+                    filterDims.push(`rec=${opts.filterRec}`);
+                if (opts.filterText !== undefined)
+                    filterDims.push(`text="${opts.filterText}"`);
+                if (opts.filterTextExact !== undefined)
+                    filterDims.push(`text-exact="${opts.filterTextExact}"`);
+                if (opts.filterRegex !== undefined)
+                    filterDims.push(`regex="${opts.filterRegex}"`);
+                if (opts.filterRegexFlags !== undefined)
+                    filterDims.push(`regex-flags="${opts.filterRegexFlags}"`);
+                if (opts.offset !== undefined)
+                    filterDims.push(`offset=${opts.offset}`);
+                const msg = filterDims.length > 0
+                    ? `No assumptions matching ${filterDims.join(', ')} recorded.\n`
+                    : 'No assumptions recorded.\n';
+                process.stdout.write(msg);
+                return;
+            }
+            for (const a of entries) {
+                process.stdout.write(`${a.id}  ${a.status}  ${a.recommendationId}  ${a.text}\n`);
+            }
+        }
+        catch (err) {
+            process.stderr.write(`assumption list failed: ${err instanceof Error ? err.message : String(err)}\n`);
+            process.exitCode = 1;
+        }
+    });
+    for (const action of ['validate', 'reject', 'reopen']) {
+        cmd
+            .command(`${action} <id>`)
+            .description(ASSUMPTION_TRANSITION_DESCRIPTIONS[action])
+            .action(async (id) => {
+            try {
+                const res = await runAssumptionTransition(process.cwd(), id, action);
+                if (!res.ok) {
+                    process.stderr.write(`assumption ${action} refused: ${res.error}\n`);
+                    process.exitCode = 1;
+                    return;
+                }
+                process.stdout.write(`assumption ${id} → ${ASSUMPTION_TRANSITION_PAST[action]}\n`);
+            }
+            catch (err) {
+                process.stderr.write(`assumption ${action} failed: ${err instanceof Error ? err.message : String(err)}\n`);
+                process.exitCode = 1;
+            }
+        });
+    }
+}
+//# sourceMappingURL=assumption.js.map