@kognai/orchestrator-core 0.1.0

package/dist/lib/model-router-registry.js

@@ -0,0 +1,52 @@
+"use strict";
+/**
+ * model-router-registry.ts — TICKET-215 Wave C: the injection point for the
+ * model-routing seam (see model-router-contract.ts).
+ *
+ * Products wire their router at startup:
+ *   - Kognai:  setModelRouter(<viem-backed ClawRouter v2 adapter>)
+ *   - others:  inject a local/product-specific ModelRouter, or leave the
+ *              fail-loud default in place until one is provided.
+ *
+ * The default is intentionally NOT a silent no-op: a routeCall with no router
+ * configured throws a clear, actionable error rather than returning empty
+ * completions. Replace with a real local-only default when one exists.
+ *
+ * Per-agent gating note: an injected router MAY consult the ACP capability
+ * registry (see ./acp) before performing a paid/on-chain call, so that only
+ * capability-bearing agents can spend — everyone else falls back to local.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setModelRouter = setModelRouter;
+exports.getModelRouter = getModelRouter;
+exports.isModelRouterConfigured = isModelRouterConfigured;
+const NOT_CONFIGURED = 'No ModelRouter registered. Call setModelRouter(...) at startup ' +
+    '(Kognai injects its viem-backed ClawRouter; other products inject their own ' +
+    'or a local router). See @kognai/orchestrator-core model-router-contract.ts.';
+class UnconfiguredModelRouter {
+    routeCall(_req) {
+        throw new Error(NOT_CONFIGURED);
+    }
+    callLLM(_prompt, _opts) {
+        throw new Error(NOT_CONFIGURED);
+    }
+    healthCheck() {
+        throw new Error(NOT_CONFIGURED);
+    }
+    getDailyCostDigest() {
+        throw new Error(NOT_CONFIGURED);
+    }
+}
+let _router = new UnconfiguredModelRouter();
+/** Inject the concrete router. Call once at process startup, before routing. */
+function setModelRouter(router) {
+    _router = router;
+}
+/** Resolve the active router. The orchestrator routes every LLM call through this. */
+function getModelRouter() {
+    return _router;
+}
+/** True once a real router has been injected (i.e. not the fail-loud default). */
+function isModelRouterConfigured() {
+    return !(_router instanceof UnconfiguredModelRouter);
+}

package/dist/lib/model-router.d.ts

@@ -0,0 +1,20 @@
+/**
+ * model-router.ts — Expertise routing matrix for ClawRouter model selection
+ *
+ * Maps task types to specialist models. Includes 3 Kognai-specific types
+ * beyond the Invoica base (refactor-complex, agent-framework, codebase-scan).
+ */
+export type TaskType = 'code' | 'reason' | 'lang' | 'util' | 'audit' | 'content' | 'data' | 'refactor-complex' | 'agent-framework' | 'codebase-scan';
+interface ModelRoute {
+    primary: string;
+    fallback: string;
+}
+declare const EXPERTISE_MODELS: Record<TaskType, ModelRoute>;
+export declare function classifyTask(prompt: string): TaskType;
+export declare function selectModel(prompt: string, requestedModel?: string): {
+    model: string;
+    taskType: TaskType;
+    autoClassified: boolean;
+};
+export declare function getFallbackModel(taskType: TaskType): string;
+export { EXPERTISE_MODELS };

package/dist/lib/model-router.js

@@ -0,0 +1,79 @@
+"use strict";
+/**
+ * model-router.ts — Expertise routing matrix for ClawRouter model selection
+ *
+ * Maps task types to specialist models. Includes 3 Kognai-specific types
+ * beyond the Invoica base (refactor-complex, agent-framework, codebase-scan).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXPERTISE_MODELS = void 0;
+exports.classifyTask = classifyTask;
+exports.selectModel = selectModel;
+exports.getFallbackModel = getFallbackModel;
+const EXPERTISE_MODELS = {
+    // Base types (same as Invoica)
+    code: { primary: 'deepseek/deepseek-chat', fallback: 'anthropic/claude-haiku-4.5' },
+    reason: { primary: 'deepseek/deepseek-reasoner', fallback: 'anthropic/claude-sonnet-4.6' },
+    lang: { primary: 'anthropic/claude-haiku-4.5', fallback: 'google/gemini-2.5-flash' },
+    util: { primary: 'google/gemini-2.5-flash-lite', fallback: 'anthropic/claude-haiku-4.5' },
+    audit: { primary: 'anthropic/claude-sonnet-4.6', fallback: 'deepseek/deepseek-chat' },
+    content: { primary: 'anthropic/claude-haiku-4.5', fallback: 'google/gemini-2.5-flash' },
+    data: { primary: 'deepseek/deepseek-chat', fallback: 'anthropic/claude-haiku-4.5' },
+    // Kognai-specific extensions
+    'refactor-complex': { primary: 'anthropic/claude-sonnet-4.6', fallback: 'deepseek/deepseek-reasoner' },
+    'agent-framework': { primary: 'deepseek/deepseek-chat', fallback: 'anthropic/claude-haiku-4.5' },
+    'codebase-scan': { primary: 'google/gemini-2.5-flash', fallback: 'deepseek/deepseek-chat' },
+};
+exports.EXPERTISE_MODELS = EXPERTISE_MODELS;
+// ── Legacy Aliases ─────────────────────────────────────────────────────────────
+const MODEL_ALIASES = {
+    'MiniMax-M2.5': 'minimax/minimax-m2.5',
+    'minimax-m2.5': 'minimax/minimax-m2.5',
+    'minimax-m2.5-lightning': 'minimax/minimax-m2.5',
+    'minimax': 'minimax/minimax-m2.5',
+    'coding': 'deepseek/deepseek-chat',
+    'claude-haiku-4-5': 'anthropic/claude-haiku-4.5',
+    'claude-haiku-4.5': 'anthropic/claude-haiku-4.5',
+    'claude-sonnet-4': 'anthropic/claude-sonnet-4.6',
+    'claude-sonnet-4.6': 'anthropic/claude-sonnet-4.6',
+    'claude-3-haiku-20240307': 'anthropic/claude-haiku-4.5',
+    'claude-3-5-sonnet-20241022': 'anthropic/claude-sonnet-4.6',
+    'claude-sonnet-4-20250514': 'anthropic/claude-sonnet-4.6',
+};
+// ── Task Classification ────────────────────────────────────────────────────────
+const TASK_PATTERNS = [
+    { type: 'refactor-complex', keywords: /\b(refactor|restructure|migration|redesign|rewrite|overhaul)\b/i },
+    { type: 'agent-framework', keywords: /\b(agent|swarm|orchestrat|pipeline|workflow|framework\s+\w+)\b/i },
+    { type: 'codebase-scan', keywords: /\b(scan|codebase|search|index|inventory|dependency\s+audit|grep)\b/i },
+    { type: 'code', keywords: /\b(code|function|debug|implement|typescript|javascript|python|fix\s+bug|compile|syntax|class\s+\w+|import\s+|async\s+function|interface\s+\w+)\b/i },
+    { type: 'audit', keywords: /\b(security|audit|review|compliance|vulnerability|penetration|cve|owasp|exploit|threat|risk\s+assess)\b/i },
+    { type: 'data', keywords: /\b(query|sql|database|aggregate|join|select\s+|group\s+by|csv|dataframe|pandas|analytics|metrics)\b/i },
+    { type: 'lang', keywords: /\b(translate|translation|french|arabic|spanish|german|chinese|japanese|locali[sz]e|multilingual|i18n)\b/i },
+    { type: 'reason', keywords: /\b(why|explain|analy[sz]e|tradeoff|compare|evaluate|pros\s+and\s+cons|reasoning|think\s+through)\b/i },
+    { type: 'content', keywords: /\b(write|draft|compose|blog|caption|essay|article|tweet|post|newsletter|marketing|creative\s+writ)\b/i },
+    { type: 'util', keywords: /\b(classify|tag|format|parse|extract|convert|summarize|json|xml|regex|validate|clean|normalize)\b/i },
+];
+function classifyTask(prompt) {
+    for (const { type, keywords } of TASK_PATTERNS) {
+        if (keywords.test(prompt))
+            return type;
+    }
+    return 'util';
+}
+function selectModel(prompt, requestedModel) {
+    if (requestedModel && requestedModel.includes('/')) {
+        return { model: requestedModel, taskType: classifyTask(prompt), autoClassified: false };
+    }
+    if (requestedModel && MODEL_ALIASES[requestedModel]) {
+        return { model: MODEL_ALIASES[requestedModel], taskType: classifyTask(prompt), autoClassified: false };
+    }
+    if (requestedModel && requestedModel in EXPERTISE_MODELS) {
+        const taskType = requestedModel;
+        return { model: EXPERTISE_MODELS[taskType].primary, taskType, autoClassified: false };
+    }
+    const taskType = classifyTask(prompt);
+    return { model: EXPERTISE_MODELS[taskType].primary, taskType, autoClassified: true };
+}
+function getFallbackModel(taskType) {
+    return EXPERTISE_MODELS[taskType].fallback;
+}

package/dist/lib/monotask-state-machine.d.ts

@@ -0,0 +1,19 @@
+export type MonotaskState = 'IDLE' | 'RESERVED' | 'ACTIVE';
+export declare class MonotaskSM {
+    private static slots;
+    private static slot;
+    private static audit;
+    private static wipe;
+    /**
+     * Attempt to claim an agent for a task.
+     * Returns false if agent is already RESERVED or ACTIVE, or depth limit exceeded.
+     * @param depth  Sub-agent chain depth (0 = top-level, 1 = first sub-agent, …)
+     */
+    static claim(agentId: string, taskId: string, depth?: number): boolean;
+    static start(agentId: string, taskId: string): boolean;
+    static complete(agentId: string, taskId: string): void;
+    static release(agentId: string, taskId: string, reason?: string): void;
+    static getState(agentId: string): MonotaskState;
+    static getDepth(agentId: string): number;
+    static isIdle(agentId: string): boolean;
+}

package/dist/lib/monotask-state-machine.js

@@ -0,0 +1,131 @@
+"use strict";
+// AMD-08 Monotask State Machine
+// IDLE → RESERVED → ACTIVE → IDLE (atomic, audit-logged)
+// Enforces: one task per agent at a time, sub-agent chain depth ≤ 3
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MonotaskSM = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+// ── Constants ────────────────────────────────────────────────────────────────
+const MAX_DEPTH = 3;
+const AUDIT_DIR = (0, path_1.join)(process.cwd(), 'logs', 'monotask');
+const AUDIT_FILE = (0, path_1.join)(AUDIT_DIR, 'audit.jsonl');
+// ── State Machine (Singleton) ────────────────────────────────────────────────
+class MonotaskSM {
+    static slots = new Map();
+    // ── Internal helpers ──────────────────────────────────────────────────────
+    static slot(agentId) {
+        if (!this.slots.has(agentId)) {
+            this.slots.set(agentId, { state: 'IDLE', taskId: null, claimedAt: null, depth: 0 });
+        }
+        return this.slots.get(agentId);
+    }
+    static audit(entry) {
+        try {
+            (0, fs_1.mkdirSync)(AUDIT_DIR, { recursive: true });
+            (0, fs_1.appendFileSync)(AUDIT_FILE, JSON.stringify(entry) + '\n', 'utf-8');
+        }
+        catch {
+            process.stderr.write('[monotask] audit write failed\n');
+        }
+    }
+    static wipe(slot) {
+        // Context Wipe Protocol (AMD-08 §3.3): clear all slot state
+        slot.state = 'IDLE';
+        slot.taskId = null;
+        slot.claimedAt = null;
+        slot.depth = 0;
+    }
+    // ── Transition: IDLE → RESERVED ──────────────────────────────────────────
+    /**
+     * Attempt to claim an agent for a task.
+     * Returns false if agent is already RESERVED or ACTIVE, or depth limit exceeded.
+     * @param depth  Sub-agent chain depth (0 = top-level, 1 = first sub-agent, …)
+     */
+    static claim(agentId, taskId, depth = 0) {
+        const s = this.slot(agentId);
+        const from = s.state;
+        if (from !== 'IDLE') {
+            this.audit({ ts: new Date().toISOString(), agentId, taskId, transition: 'claim_rejected',
+                from, to: from, depth, reason: `Agent already ${from} on task ${s.taskId ?? '?'}` });
+            process.stderr.write(`[monotask] CLAIM REJECTED — ${agentId} is ${from} (task: ${s.taskId})\n`);
+            return false;
+        }
+        if (depth > MAX_DEPTH) {
+            this.audit({ ts: new Date().toISOString(), agentId, taskId, transition: 'depth_exceeded',
+                from, to: from, depth, reason: `Depth ${depth} > MAX_DEPTH ${MAX_DEPTH}` });
+            process.stderr.write(`[monotask] DEPTH EXCEEDED — ${agentId} depth ${depth} > ${MAX_DEPTH}\n`);
+            return false;
+        }
+        s.state = 'RESERVED';
+        s.taskId = taskId;
+        s.claimedAt = new Date();
+        s.depth = depth;
+        this.audit({ ts: new Date().toISOString(), agentId, taskId, transition: 'IDLE→RESERVED',
+            from: 'IDLE', to: 'RESERVED', depth });
+        return true;
+    }
+    // ── Transition: RESERVED → ACTIVE ────────────────────────────────────────
+    static start(agentId, taskId) {
+        const s = this.slot(agentId);
+        const from = s.state;
+        if (from !== 'RESERVED') {
+            this.audit({ ts: new Date().toISOString(), agentId, taskId, transition: 'start_rejected',
+                from, to: from, reason: `Expected RESERVED, got ${from}` });
+            return false;
+        }
+        s.state = 'ACTIVE';
+        this.audit({ ts: new Date().toISOString(), agentId, taskId, transition: 'RESERVED→ACTIVE',
+            from: 'RESERVED', to: 'ACTIVE', depth: s.depth });
+        return true;
+    }
+    // ── Transition: ACTIVE → IDLE (successful completion) ────────────────────
+    static complete(agentId, taskId) {
+        const s = this.slot(agentId);
+        const from = s.state;
+        this.audit({ ts: new Date().toISOString(), agentId, taskId, transition: `${from}→IDLE`,
+            from, to: 'IDLE', depth: s.depth });
+        this.wipe(s);
+    }
+    // ── Transition: any → IDLE (error / rejection between retries) ───────────
+    static release(agentId, taskId, reason) {
+        const s = this.slot(agentId);
+        const from = s.state;
+        this.audit({ ts: new Date().toISOString(), agentId, taskId, transition: `${from}→IDLE(release)`,
+            from, to: 'IDLE', depth: s.depth, reason });
+        this.wipe(s);
+    }
+    // ── Queries ───────────────────────────────────────────────────────────────
+    static getState(agentId) {
+        return this.slot(agentId).state;
+    }
+    static getDepth(agentId) {
+        return this.slot(agentId).depth;
+    }
+    static isIdle(agentId) {
+        return this.slot(agentId).state === 'IDLE';
+    }
+}
+exports.MonotaskSM = MonotaskSM;
+// ── Smoke test ────────────────────────────────────────────────────────────────
+if (require.main === module) {
+    console.log('\n🤖 AMD-08 Monotask State Machine — Smoke Test\n');
+    const agent = 'test-agent';
+    // Happy path
+    console.assert(MonotaskSM.isIdle(agent), 'should start IDLE');
+    console.assert(MonotaskSM.claim(agent, 't1'), 'claim should succeed');
+    console.assert(MonotaskSM.getState(agent) === 'RESERVED', 'should be RESERVED');
+    console.assert(!MonotaskSM.claim(agent, 't2'), 'double-claim should fail');
+    console.assert(MonotaskSM.start(agent, 't1'), 'start should succeed');
+    console.assert(MonotaskSM.getState(agent) === 'ACTIVE', 'should be ACTIVE');
+    MonotaskSM.complete(agent, 't1');
+    console.assert(MonotaskSM.isIdle(agent), 'should be IDLE after complete');
+    // Depth guard
+    console.assert(MonotaskSM.claim('deep-agent', 'td', MAX_DEPTH + 1) === false, 'depth > MAX_DEPTH should fail');
+    // Release path
+    MonotaskSM.claim('r-agent', 'tr');
+    MonotaskSM.start('r-agent', 'tr');
+    MonotaskSM.release('r-agent', 'tr', 'rejection');
+    console.assert(MonotaskSM.isIdle('r-agent'), 'should be IDLE after release');
+    console.log('✅ PASS — audit log written to logs/monotask/audit.jsonl\n');
+}

package/dist/lib/neutral-prompt-checker.d.ts

@@ -0,0 +1,22 @@
+/**
+ * neutral-prompt-checker.ts — Sprint TICKET-005-RULE1
+ * Rule 1 (Neutral Prompts): detects answer-seeding in sprint descriptions.
+ *
+ * Answer-seeding = embedding specific implementation choices in a brief that
+ * should remain open-ended: code fences, import statements, copy-X patterns.
+ *
+ * Usage:
+ *   npx ts-node scripts/governance/neutral-prompt-checker.ts --file=workspace/sprint-brief.md
+ *   echo "description text" | npx ts-node scripts/governance/neutral-prompt-checker.ts
+ *
+ * Exit 0 = clean, Exit 1 = violations found
+ */
+export interface NeutralCheckResult {
+    clean: boolean;
+    violations: Array<{
+        line: number;
+        pattern: string;
+        text: string;
+    }>;
+}
+export declare function checkText(text: string): NeutralCheckResult;

package/dist/lib/neutral-prompt-checker.js

@@ -0,0 +1,130 @@
+"use strict";
+/**
+ * neutral-prompt-checker.ts — Sprint TICKET-005-RULE1
+ * Rule 1 (Neutral Prompts): detects answer-seeding in sprint descriptions.
+ *
+ * Answer-seeding = embedding specific implementation choices in a brief that
+ * should remain open-ended: code fences, import statements, copy-X patterns.
+ *
+ * Usage:
+ *   npx ts-node scripts/governance/neutral-prompt-checker.ts --file=workspace/sprint-brief.md
+ *   echo "description text" | npx ts-node scripts/governance/neutral-prompt-checker.ts
+ *
+ * Exit 0 = clean, Exit 1 = violations found
+ */
+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.checkText = checkText;
+const fs = __importStar(require("fs"));
+// Patterns that indicate answer-seeding
+const SEEDING_RULES = [
+    {
+        pattern: 'code-fence',
+        regex: /^```/,
+        description: 'Code fence in brief — implementation details should not be pre-seeded',
+    },
+    {
+        pattern: 'import-statement',
+        regex: /^\s*(import |from ['"]|require\()/,
+        description: 'Import statement — specific module choices should not be pre-seeded',
+    },
+    {
+        pattern: 'code-statement',
+        regex: /^\s*(const |let |var |function |class |export |async function )\w+/,
+        description: 'Code statement — implementation should not be pre-seeded',
+    },
+    {
+        pattern: 'copy-pattern',
+        regex: /\b(copy from|same as Sprint|exactly like|same pattern|use the same code|port from)\b/i,
+        description: 'Copy-from instruction — should describe intent, not implementation',
+    },
+    {
+        pattern: 'hardcoded-identifier',
+        regex: /\b([a-z][a-zA-Z]{14,}|[a-z]+(_[a-z]+){4,})\b/,
+        description: 'Very long identifier — may indicate pre-seeded variable/function name',
+    },
+];
+function checkText(text) {
+    const lines = text.split('\n');
+    const violations = [];
+    let inCodeFence = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Track code fence state
+        if (line.trim().startsWith('```')) {
+            inCodeFence = !inCodeFence;
+            // Flag the opening fence itself (but not closing)
+            if (inCodeFence) {
+                violations.push({ line: i + 1, pattern: 'code-fence', text: line.trim().slice(0, 60) });
+            }
+            continue;
+        }
+        // Skip lines inside code fences (already flagged by opening)
+        if (inCodeFence)
+            continue;
+        for (const rule of SEEDING_RULES) {
+            if (rule.pattern === 'code-fence')
+                continue; // handled above
+            if (rule.regex.test(line)) {
+                violations.push({ line: i + 1, pattern: rule.pattern, text: line.trim().slice(0, 80) });
+                break; // one violation per line
+            }
+        }
+    }
+    return { clean: violations.length === 0, violations };
+}
+// CLI entrypoint
+if (require.main === module) {
+    let text = '';
+    const fileArg = process.argv.find(a => a.startsWith('--file='));
+    if (fileArg) {
+        text = fs.readFileSync(fileArg.split('=')[1], 'utf-8');
+    }
+    else {
+        text = fs.readFileSync('/dev/stdin', 'utf-8');
+    }
+    const result = checkText(text);
+    if (result.clean) {
+        console.log('✓ Rule 1 check PASS — no answer-seeding detected');
+        process.exit(0);
+    }
+    else {
+        console.error(`✗ Rule 1 check FAIL — ${result.violations.length} violation(s):`);
+        result.violations.forEach(v => {
+            console.error(`  Line ${v.line} [${v.pattern}]: ${v.text}`);
+        });
+        process.exit(1);
+    }
+}

package/dist/lib/notion-direct.d.ts

@@ -0,0 +1,92 @@
+/**
+ * notion-direct.ts — Zero-dep Notion API client for senior-coder.
+ *
+ * Bypasses both OpenClaw and the @notionhq/client npm package (which would be a
+ * new dep). Uses raw HTTPS to api.notion.com.
+ *
+ * Public surface — only what the bot actually needs:
+ *   - upsertSprint(sprint)        → push a sprint to Notion Sprints DB (create or update by Sprint ID)
+ *   - updateSprintStatus(id, ...) → patch a sprint's status/outcome after completion
+ *   - createBlocker(blocker)      → push a blocker to Notion Blockers DB
+ *   - archiveDailyBrief(date,...) → create a sub-page under the Daily Briefs parent
+ *   - queryNewSprintsInNotion()   → pull sprints with Status=pending that don't exist locally yet
+ *
+ * Fail-open: every function returns {ok: false, reason} on error rather than
+ * throwing, so the bot pipeline doesn't break when Notion is down or the
+ * integration loses access. Callers log the failure and continue.
+ *
+ * Created: 2026-04-29.
+ */
+export interface NotionResult<T = unknown> {
+    ok: boolean;
+    reason?: string;
+    data?: T;
+}
+export interface SprintRow {
+    sprint_id: string;
+    title: string;
+    status: 'pending' | 'running' | 'done' | 'done-manual' | 'rejected' | 'loop-stuck' | 'skipped';
+    priority?: 'P0' | 'P1' | 'P2' | 'P3';
+    tasks_summary?: string;
+    authored_by?: 'human' | 'senior-coder' | 'swarm' | 'founder' | 'miner';
+    sprint_file_url?: string;
+    outcome?: string;
+}
+export interface BlockerRow {
+    title: string;
+    sprint_page_id?: string;
+    detected_at_iso: string;
+    pick_count_24h: number;
+    status: 'open' | 'awaiting-dev' | 'awaiting-founder' | 'resolved' | 'wont-fix';
+    diagnosis?: string;
+    resolution?: string;
+}
+/**
+ * Upsert a sprint row in Notion. Creates if not exists (by Sprint ID), updates if it does.
+ * Returns the page_id of the row in Notion (useful for setting Blocker.Sprint relation).
+ */
+export declare function upsertSprint(s: SprintRow): Promise<NotionResult<{
+    page_id: string;
+}>>;
+/**
+ * Lighter-weight update: only patches status (+ optional outcome). Use after sprint completion.
+ */
+export declare function updateSprintStatus(sprintId: string, status: SprintRow['status'], outcome?: string, tasksSummary?: string): Promise<NotionResult>;
+export declare function createBlocker(b: BlockerRow): Promise<NotionResult<{
+    page_id: string;
+}>>;
+/**
+ * Create a sub-page under the Daily Briefs parent, titled by date, with the
+ * brief text as content. Notion pages support markdown-ish content via blocks;
+ * we use a single paragraph with the brief text (wrapped in code-block-style).
+ */
+export declare function archiveDailyBrief(dateIso: string, briefText: string): Promise<NotionResult<{
+    page_id: string;
+}>>;
+export interface NotionAuthoredSprint {
+    page_id: string;
+    sprint_id: string;
+    title: string;
+    status: string;
+    priority?: string;
+    tasks_summary?: string;
+    authored_by?: string;
+}
+/**
+ * Fetch all sprint rows in Notion with Status=pending. Caller compares against
+ * local `workspace/sprints/` to find which ones to materialize as JSON files.
+ */
+export declare function queryPendingSprintsFromNotion(): Promise<NotionResult<NotionAuthoredSprint[]>>;
+/**
+ * Fetch ALL sprints in the Notion Sprints DB, return a Map of sprint_id → status.
+ * Used by sprint-runner.ts so Notion overrides local file state — protects against
+ * other Claude sessions reverting sprint files locally.
+ * Fail-safe: returns {ok: false} on Notion error so caller falls back to local-only.
+ */
+export declare function getAllNotionSprintStatuses(): Promise<NotionResult<Map<string, string>>>;
+export declare function notionHealthCheck(): Promise<NotionResult<{
+    bot_name: string;
+    sprints_db: boolean;
+    blockers_db: boolean;
+    briefs_page: boolean;
+}>>;