@ouro.bot/cli 0.1.0-alpha.157 → 0.1.0-alpha.159

package/dist/repertoire/guardrails.js

@@ -162,6 +162,7 @@ exports.OURO_CLI_TRUST_MANIFEST = {
     "task actionable": "friend",
     "task deps": "friend",
     "task sessions": "friend",
+    "task fix": "friend",
     "friend list": "friend",
     "friend show": "friend",
     "friend create": "friend",

package/dist/repertoire/tasks/board.js

@@ -7,14 +7,21 @@ exports.boardDeps = boardDeps;
 exports.boardSessions = boardSessions;
 const runtime_1 = require("../../nerves/runtime");
 const transitions_1 = require("./transitions");
-const BOARD_STATUS_ORDER = [
+const BOARD_ACTIVE_ORDER = [
     "blocked",
     "processing",
     "collaborating",
     "drafting",
     "validating",
     "paused",
+];
+const BOARD_TERMINAL_ORDER = [
     "done",
+    "cancelled",
+];
+const BOARD_STATUS_ORDER = [
+    ...BOARD_ACTIVE_ORDER,
+    ...BOARD_TERMINAL_ORDER,
 ];
 function compactName(task) {
     const suffix = task.stem.replace(/^\d{4}-\d{2}-\d{2}-\d{4}-/, "");
@@ -29,6 +36,7 @@ function groupByStatus(tasks) {
         paused: [],
         blocked: [],
         done: [],
+        cancelled: [],
     };
     for (const task of tasks) {
         grouped[task.status].push(compactName(task));
@@ -65,8 +73,20 @@ function activeBridgeLines(tasks) {
         .map((task) => `${task.stem} -> ${String(task.frontmatter.active_bridge).trim()}`)
         .sort();
 }
+function buildHealthLine(issues) {
+    if (issues.length === 0)
+        return "health: clean";
+    const liveCount = issues.filter((i) => i.category === "live").length;
+    const migrationCount = issues.filter((i) => i.category === "migration").length;
+    const parts = [];
+    if (liveCount > 0)
+        parts.push(`${liveCount} live`);
+    if (migrationCount > 0)
+        parts.push(`${migrationCount} migration`);
+    return `health: ${parts.join(", ")}`;
+}
 function actionRequired(index, byStatus) {
-    const actions = [...index.parseErrors, ...index.invalidFilenames.map((filePath) => `bad filename: ${filePath}`)];
+    const actions = index.issues.map((issue) => `${issue.code}: ${issue.description} [${issue.target}]`);
     if (byStatus.blocked.length > 0) {
         actions.push(`blocked tasks: ${byStatus.blocked.join(", ")}`);
     }
@@ -83,14 +103,19 @@ function buildTaskBoard(index) {
         meta: { taskCount: index.tasks.length },
     });
     const byStatus = groupByStatus(index.tasks);
-    const counts = transitions_1.TASK_VALID_STATUSES.map((status) => `${status}:${byStatus[status].length}`).join(" ");
+    const activeCounts = BOARD_ACTIVE_ORDER.map((status) => `${status}:${byStatus[status].length}`).join(" ");
     const processing = byStatus.processing.length > 0 ? `\n processing: ${byStatus.processing.join(", ")}` : "";
     const blocked = byStatus.blocked.length > 0 ? `\n blocked: ${byStatus.blocked.join(", ")}` : "";
-    const compact = `[Tasks] ${counts}${processing}${blocked}`;
+    const terminalParts = BOARD_TERMINAL_ORDER
+        .filter((status) => byStatus[status].length > 0)
+        .map((status) => `${status}:${byStatus[status].length}`);
+    const terminalLine = terminalParts.length > 0 ? `\n terminal: ${terminalParts.join(" ")}` : "";
+    const healthLine = `\n ${buildHealthLine(index.issues)}`;
+    const compact = `[Tasks] ${activeCounts}${processing}${blocked}${terminalLine}${healthLine}`;
     const fullLines = [];
     for (const status of BOARD_STATUS_ORDER) {
         const names = byStatus[status];
-        if (status === "done" && names.length === 0)
+        if ((status === "done" || status === "cancelled") && names.length === 0)
             continue;
         fullLines.push(`## ${status}`);
         fullLines.push(names.length > 0 ? names.map((name) => `- ${name}`).join("\n") : "- (none)");
@@ -114,6 +139,7 @@ function buildTaskBoard(index) {
         compact,
         full: fullLines.join("\n\n"),
         byStatus,
+        issues: index.issues,
         actionRequired: actionRequired(index, byStatus),
         unresolvedDependencies: unresolved,
         activeSessions: active,

package/dist/repertoire/tasks/fix.js

@@ -0,0 +1,182 @@
+"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.addKindToLegacyCard = addKindToLegacyCard;
+exports.applyFixes = applyFixes;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+const scanner_1 = require("./scanner");
+const parser_1 = require("./parser");
+function issueId(issue) {
+    return `${issue.code}:${issue.target}`;
+}
+function addKindToLegacyCard(root, issue) {
+    (0, runtime_1.emitNervesEvent)({
+        event: "repertoire.fix_apply_start",
+        component: "repertoire",
+        message: "adding kind: task to legacy card",
+        meta: { target: issue.target },
+    });
+    const filePath = path.join(root, issue.target);
+    if (!fs.existsSync(filePath))
+        return false;
+    const content = fs.readFileSync(filePath, "utf-8");
+    const frontmatter = (0, scanner_1.tryExtractFrontmatter)(content);
+    if (!frontmatter)
+        return false;
+    // Add kind: task to frontmatter
+    frontmatter.kind = "task";
+    // Extract body (everything after the second ---)
+    const lines = content.split(/\r?\n/);
+    const firstDelim = lines.findIndex((line) => line.trim() === "---");
+    const secondDelim = lines.findIndex((line, idx) => idx > firstDelim && line.trim() === "---");
+    const body = lines.slice(secondDelim + 1).join("\n").replace(/^\n/, "");
+    const rendered = (0, parser_1.renderTaskFile)(frontmatter, body);
+    fs.writeFileSync(filePath, rendered, "utf-8");
+    return true;
+}
+function applySingleFix(root, issue) {
+    switch (issue.code) {
+        case "schema-missing-kind":
+            return addKindToLegacyCard(root, issue);
+        default:
+            return false;
+    }
+}
+function applyFixes(options, root) {
+    (0, runtime_1.emitNervesEvent)({
+        event: "repertoire.fix_start",
+        component: "repertoire",
+        message: `applying fixes in ${options.mode} mode`,
+        meta: { mode: options.mode, root },
+    });
+    (0, scanner_1.clearTaskScanCache)();
+    const index = (0, scanner_1.scanTasks)(root);
+    const issues = index.issues;
+    if (options.mode === "dry-run") {
+        (0, runtime_1.emitNervesEvent)({
+            event: "repertoire.fix_complete",
+            component: "repertoire",
+            message: "dry-run complete, no changes made",
+            meta: { issueCount: issues.length },
+        });
+        const health = issues.length === 0 ? "clean" : buildHealthSummary(issues);
+        return {
+            applied: [],
+            remaining: issues,
+            skipped: [],
+            health,
+        };
+    }
+    if (options.mode === "single") {
+        const targetId = options.issueId ?? "";
+        const match = issues.find((i) => issueId(i) === targetId);
+        if (!match) {
+            (0, runtime_1.emitNervesEvent)({
+                event: "repertoire.fix_complete",
+                component: "repertoire",
+                message: "single fix: issue not found",
+                meta: { issueId: targetId },
+            });
+            const health = issues.length === 0 ? "clean" : buildHealthSummary(issues);
+            return {
+                applied: [],
+                remaining: issues,
+                skipped: [],
+                health,
+            };
+        }
+        const success = applySingleFix(root, match);
+        (0, scanner_1.clearTaskScanCache)();
+        const afterIndex = (0, scanner_1.scanTasks)(root);
+        const afterIssues = afterIndex.issues;
+        const health = afterIssues.length === 0 ? "clean" : buildHealthSummary(afterIssues);
+        (0, runtime_1.emitNervesEvent)({
+            event: "repertoire.fix_complete",
+            component: "repertoire",
+            message: `single fix ${success ? "applied" : "failed"}`,
+            meta: { issueId: targetId, success },
+        });
+        return {
+            applied: success ? [match] : [],
+            remaining: afterIssues,
+            skipped: success ? [] : [match],
+            health,
+        };
+    }
+    // safe mode: apply all safe-confidence fixes
+    const applied = [];
+    const skipped = [];
+    for (const issue of issues) {
+        if (issue.confidence !== "safe") {
+            skipped.push(issue);
+            continue;
+        }
+        const success = applySingleFix(root, issue);
+        if (success) {
+            applied.push(issue);
+        }
+        else {
+            skipped.push(issue);
+        }
+    }
+    (0, scanner_1.clearTaskScanCache)();
+    const afterIndex = (0, scanner_1.scanTasks)(root);
+    const afterIssues = afterIndex.issues;
+    const health = afterIssues.length === 0 ? "clean" : buildHealthSummary(afterIssues);
+    (0, runtime_1.emitNervesEvent)({
+        event: "repertoire.fix_complete",
+        component: "repertoire",
+        message: `safe fixes complete: ${applied.length} applied, ${skipped.length} skipped`,
+        meta: { applied: applied.length, skipped: skipped.length },
+    });
+    return {
+        applied,
+        remaining: afterIssues,
+        skipped,
+        health,
+    };
+}
+function buildHealthSummary(issues) {
+    const liveCount = issues.filter((i) => i.category === "live").length;
+    const migrationCount = issues.filter((i) => i.category === "migration").length;
+    const parts = [];
+    if (liveCount > 0)
+        parts.push(`${liveCount} live`);
+    if (migrationCount > 0)
+        parts.push(`${migrationCount} migration`);
+    return parts.join(", ");
+}

package/dist/repertoire/tasks/index.js

@@ -40,6 +40,7 @@ const path = __importStar(require("path"));
 const config_1 = require("../../heart/config");
 const runtime_1 = require("../../nerves/runtime");
 const board_1 = require("./board");
+const fix_1 = require("./fix");
 const lifecycle_1 = require("./lifecycle");
 const parser_1 = require("./parser");
 const scanner_1 = require("./scanner");
@@ -97,6 +98,7 @@ class FileTaskModule {
         const filePath = path.join(root, collection, filename);
         const today = formatDate();
         const frontmatter = {
+            kind: "task",
             type,
             category: input.category || "infrastructure",
             title: input.title,
@@ -108,7 +110,6 @@ class FileTaskModule {
             lastRun: input.lastRun ?? null,
             created: today,
             updated: today,
-            child_tasks: [],
             artifacts: [],
         };
         if (type === "one-shot") {
@@ -192,6 +193,9 @@ class FileTaskModule {
         }
         return (0, middleware_1.validateSpawn)(task, spawnType);
     }
+    fix(options) {
+        return (0, fix_1.applyFixes)(options, (0, scanner_1.getTaskRoot)());
+    }
     detectStale(thresholdDays) {
         return (0, lifecycle_1.detectStaleTasks)(this.scan(), thresholdDays);
     }

package/dist/repertoire/tasks/lifecycle.js

@@ -48,7 +48,7 @@ function archiveCompletedTasks(index) {
     const archived = [];
     const failures = [];
     for (const task of index.tasks) {
-        if (task.status !== "done")
+        if (task.status !== "done" && task.status !== "cancelled")
             continue;
         const archiveDir = path.join(index.root, "archive", task.collection);
         const archiveFile = path.join(archiveDir, task.name);
@@ -73,7 +73,7 @@ function detectStaleTasks(index, thresholdDays, now = new Date()) {
         const updated = Date.parse(task.updated);
         if (Number.isNaN(updated))
             return false;
-        if (task.status === "done")
+        if (task.status === "done" || task.status === "cancelled")
             return false;
         return updated < staleCutoffMs;
     });

package/dist/repertoire/tasks/parser.js

@@ -136,6 +136,9 @@ function parseTaskFile(content, filePath) {
             _isCanonicalFilename: (0, transitions_1.isCanonicalTaskFilename)(name),
         },
         body: parsed.body,
+        hasWorkDir: false,
+        workDirFiles: [],
+        derivedChildren: [],
     };
 }
 function formatFrontmatterValue(value) {

package/dist/repertoire/tasks/scanner.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTaskRoot = getTaskRoot;
 exports.ensureTaskLayout = ensureTaskLayout;
+exports.tryExtractFrontmatter = tryExtractFrontmatter;
 exports.clearTaskScanCache = clearTaskScanCache;
 exports.scanTasks = scanTasks;
 const fs = __importStar(require("fs"));
@@ -59,30 +60,57 @@ function ensureTaskLayout(root = getTaskRoot()) {
         fs.mkdirSync(dir, { recursive: true });
     }
 }
-function walkMarkdownFiles(dir, acc) {
-    if (!fs.existsSync(dir))
-        return;
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-        if (entry.isDirectory()) {
-            if (transitions_1.TASK_RESERVED_DIRECTORIES.includes(entry.name)) {
+/**
+ * Attempt to extract frontmatter from markdown content.
+ * Returns parsed frontmatter dict or null. Never throws.
+ */
+function tryExtractFrontmatter(content) {
+    (0, runtime_1.emitNervesEvent)({
+        event: "repertoire.frontmatter_extract_start",
+        component: "repertoire",
+        message: "attempting frontmatter extraction",
+    });
+    const lines = content.split(/\r?\n/);
+    if (lines[0]?.trim() !== "---") {
+        return null;
+    }
+    const closing = lines.findIndex((line, index) => index > 0 && line.trim() === "---");
+    if (closing === -1) {
+        return null;
+    }
+    const rawFrontmatter = lines.slice(1, closing).join("\n");
+    return (0, parser_1.parseFrontmatter)(rawFrontmatter);
+}
+const LEGACY_TASK_TYPES = ["one-shot", "ongoing", "habit"];
+function buildFingerprint(root) {
+    (0, runtime_1.emitNervesEvent)({
+        event: "repertoire.fingerprint_build_start",
+        component: "repertoire",
+        message: "building scan fingerprint",
+        meta: { root },
+    });
+    const segments = [];
+    for (const collection of transitions_1.TASK_CANONICAL_COLLECTIONS) {
+        const collDir = path.join(root, collection);
+        const entries = fs.readdirSync(collDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isFile() || !entry.name.endsWith(".md"))
                 continue;
-            }
-            walkMarkdownFiles(path.join(dir, entry.name), acc);
-            continue;
-        }
-        if (entry.name.endsWith(".md")) {
-            acc.push(path.join(dir, entry.name));
+            const filePath = path.join(collDir, entry.name);
+            const stat = fs.statSync(filePath);
+            segments.push(`${filePath}:${stat.mtimeMs}:${stat.size}`);
         }
     }
-}
-function buildFingerprint(paths) {
-    const segments = paths
-        .map((filePath) => {
+    // Also include root-level md files for orphan detection fingerprinting
+    const rootEntries = fs.readdirSync(root, { withFileTypes: true });
+    for (const entry of rootEntries) {
+        if (!entry.isFile() || !entry.name.endsWith(".md"))
+            continue;
+        const filePath = path.join(root, entry.name);
         const stat = fs.statSync(filePath);
-        return `${filePath}:${stat.mtimeMs}:${stat.size}`;
-    })
-        .sort();
+        segments.push(`${filePath}:${stat.mtimeMs}:${stat.size}`);
+    }
+    segments.sort();
     return segments.join("|");
 }
 function clearTaskScanCache() {
@@ -96,35 +124,164 @@ function scanTasks(root = getTaskRoot()) {
         meta: { root },
     });
     ensureTaskLayout(root);
-    const files = [];
-    for (const collection of transitions_1.TASK_CANONICAL_COLLECTIONS) {
-        walkMarkdownFiles(path.join(root, collection), files);
-    }
-    const fingerprint = buildFingerprint(files);
+    const fingerprint = buildFingerprint(root);
     if (scanCache && scanCache.fingerprint === fingerprint) {
         return scanCache.index;
     }
     const tasks = [];
-    const parseErrors = [];
-    const invalidFilenames = [];
-    for (const filePath of files) {
-        const base = path.basename(filePath);
-        if (!(0, transitions_1.isCanonicalTaskFilename)(base)) {
-            invalidFilenames.push(filePath);
+    const issues = [];
+    // Scan each collection with flat directory reads (no recursion)
+    for (const collection of transitions_1.TASK_CANONICAL_COLLECTIONS) {
+        const collDir = path.join(root, collection);
+        const entries = fs.readdirSync(collDir, { withFileTypes: true });
+        const dirNames = new Set();
+        // Collect directory names for work dir detection
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                dirNames.add(entry.name);
+            }
         }
-        try {
+        // Process only .md files at collection root (flat, no recursion)
+        let supportDocCount = 0;
+        for (const entry of entries) {
+            if (!entry.isFile() || !entry.name.endsWith(".md"))
+                continue;
+            const filePath = path.join(collDir, entry.name);
             const content = fs.readFileSync(filePath, "utf-8");
-            tasks.push((0, parser_1.parseTaskFile)(content, filePath));
+            // Step 1: Try to extract frontmatter
+            const frontmatter = tryExtractFrontmatter(content);
+            if (!frontmatter) {
+                // No frontmatter — not a task, count as support doc clutter
+                supportDocCount += 1;
+                continue;
+            }
+            // Step 2: Check kind: task
+            const isKindTask = frontmatter.kind === "task";
+            const fmType = typeof frontmatter.type === "string" ? frontmatter.type.trim().toLowerCase() : "";
+            const isLegacyTask = !isKindTask && LEGACY_TASK_TYPES.includes(fmType);
+            if (!isKindTask && !isLegacyTask) {
+                // Has frontmatter but not a task — skip silently
+                continue;
+            }
+            // Step 3: Emit migration issue for legacy task
+            if (isLegacyTask) {
+                const relPath = path.relative(root, filePath);
+                issues.push({
+                    target: relPath,
+                    code: "schema-missing-kind",
+                    description: "Task card missing kind: task field",
+                    fix: "Add kind: task to frontmatter",
+                    confidence: "safe",
+                    category: "migration",
+                });
+            }
+            // Step 4: Parse the task file
+            try {
+                const task = (0, parser_1.parseTaskFile)(content, filePath);
+                // Check filename canonicality
+                const base = path.basename(filePath);
+                if (!(0, transitions_1.isCanonicalTaskFilename)(base)) {
+                    const relPath = path.relative(root, filePath);
+                    issues.push({
+                        target: relPath,
+                        code: "filename-not-canonical",
+                        description: `Non-canonical filename: ${base}`,
+                        fix: `Rename to canonical format (YYYY-MM-DD-HHMM-slug.md)`,
+                        confidence: "safe",
+                        category: "migration",
+                    });
+                }
+                // Work dir detection
+                const stem = base.replace(/\.md$/i, "");
+                if (dirNames.has(stem)) {
+                    task.hasWorkDir = true;
+                    const workDirPath = path.join(collDir, stem);
+                    task.workDirFiles = fs.readdirSync(workDirPath).sort();
+                }
+                tasks.push(task);
+            }
+            catch (error) {
+                // Parse error on a file we identified as a task — real issue
+                const relPath = path.relative(root, filePath);
+                issues.push({
+                    target: relPath,
+                    code: "schema-invalid",
+                    description: `Parse error: ${error instanceof Error ? error.message : String(error)}`,
+                    fix: "Fix the task card schema (ensure required fields: type, status, etc.)",
+                    confidence: "needs_review",
+                    category: "live",
+                });
+            }
+        }
+        // Summarize non-task support docs at collection root as one migration issue
+        if (supportDocCount > 0) {
+            (0, runtime_1.emitNervesEvent)({
+                event: "repertoire.support_docs_detected",
+                component: "repertoire",
+                message: "non-task support documents at collection root",
+                meta: { collection, count: supportDocCount },
+            });
+            issues.push({
+                target: collection,
+                code: "org-collection-root-clutter",
+                description: `${supportDocCount} non-task file${supportDocCount === 1 ? "" : "s"} at ${collection}/ root (doing docs, planning docs, etc.)`,
+                fix: "Move support docs into same-stem work directories for their parent tasks",
+                confidence: "needs_review",
+                category: "migration",
+            });
+        }
+    }
+    // Orphan detection: root-level .md files outside any canonical collection
+    const rootEntries = fs.readdirSync(root, { withFileTypes: true });
+    const collectionSet = new Set(transitions_1.TASK_CANONICAL_COLLECTIONS);
+    for (const entry of rootEntries) {
+        if (!entry.isFile() || !entry.name.endsWith(".md"))
+            continue;
+        const filePath = path.join(root, entry.name);
+        const content = fs.readFileSync(filePath, "utf-8");
+        const frontmatter = tryExtractFrontmatter(content);
+        // Only flag as orphan if it has task-like frontmatter
+        if (!frontmatter)
+            continue;
+        const fmType = typeof frontmatter.type === "string" ? frontmatter.type.trim().toLowerCase() : "";
+        const hasTaskLikeContent = frontmatter.kind === "task" ||
+            LEGACY_TASK_TYPES.includes(fmType) ||
+            (typeof frontmatter.status === "string" && typeof frontmatter.title === "string");
+        if (hasTaskLikeContent) {
+            (0, runtime_1.emitNervesEvent)({
+                event: "repertoire.orphan_detected",
+                component: "repertoire",
+                message: "root-level orphan document detected",
+                meta: { filePath },
+            });
+            issues.push({
+                target: entry.name,
+                code: "org-root-level-doc",
+                description: `Root-level document outside any collection: ${entry.name}`,
+                fix: `Move to appropriate collection directory (${[...collectionSet].join(", ")})`,
+                confidence: "needs_review",
+                category: "migration",
+            });
         }
-        catch (error) {
-            parseErrors.push(`${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    // Populate derivedChildren from parent_task links
+    const stemToTask = new Map();
+    for (const task of tasks) {
+        stemToTask.set(task.stem, task);
+    }
+    for (const task of tasks) {
+        const parentStem = typeof task.frontmatter.parent_task === "string"
+            ? task.frontmatter.parent_task.trim()
+            : "";
+        if (parentStem && stemToTask.has(parentStem)) {
+            const parent = stemToTask.get(parentStem);
+            parent.derivedChildren.push(task.stem);
         }
     }
     const index = {
         root,
         tasks,
-        invalidFilenames,
-        parseErrors,
+        issues,
         fingerprint,
     };
     scanCache = { fingerprint, index };

package/dist/repertoire/tasks/transitions.js

@@ -16,15 +16,17 @@ exports.TASK_VALID_STATUSES = [
     "paused",
     "blocked",
     "done",
+    "cancelled",
 ];
 exports.TASK_STATUS_TRANSITIONS = {
-    drafting: ["processing", "collaborating"],
-    processing: ["validating", "paused", "blocked"],
-    validating: ["done", "processing", "collaborating"],
-    collaborating: ["processing", "validating", "paused"],
-    paused: ["processing", "blocked"],
-    blocked: ["processing", "paused"],
+    drafting: ["processing", "collaborating", "cancelled"],
+    processing: ["validating", "paused", "blocked", "cancelled"],
+    validating: ["done", "processing", "collaborating", "cancelled"],
+    collaborating: ["processing", "validating", "paused", "cancelled"],
+    paused: ["processing", "blocked", "cancelled"],
+    blocked: ["processing", "paused", "cancelled"],
     done: [],
+    cancelled: [],
 };
 exports.TASK_CANONICAL_TYPES = [
     "one-shot",
@@ -42,6 +44,7 @@ exports.TASK_RESERVED_DIRECTORIES = ["templates", ".trash", "archive"];
 exports.TASK_FILENAME_PATTERN = /^\d{4}-\d{2}-\d{2}-\d{4}-[a-z0-9][a-z0-9-]*\.md$/;
 exports.TASK_REQUIRED_TEMPLATE_FIELDS = {
     "one-shot": [
+        "kind",
         "type",
         "category",
         "title",
@@ -55,10 +58,10 @@ exports.TASK_REQUIRED_TEMPLATE_FIELDS = {
         "updated",
         "parent_task",
         "depends_on",
-        "child_tasks",
         "artifacts",
     ],
     ongoing: [
+        "kind",
         "type",
         "category",
         "title",
@@ -70,7 +73,6 @@ exports.TASK_REQUIRED_TEMPLATE_FIELDS = {
         "lastRun",
         "created",
         "updated",
-        "child_tasks",
         "artifacts",
     ],
 };

package/dist/repertoire/tools-base.js

@@ -179,7 +179,9 @@ function emptyTaskBoard() {
             paused: [],
             blocked: [],
             done: [],
+            cancelled: [],
         },
+        issues: [],
         actionRequired: [],
         unresolvedDependencies: [],
         activeSessions: [],

package/dist/senses/bluebubbles-client.js

@@ -441,7 +441,7 @@ function createBlueBubblesClient(config = (0, config_1.getBlueBubblesConfig)(),
                     hydrated.balloonBundleId !== "com.apple.messages.URLBalloonProvider" &&
                     hydrated.attachments.length > 0) {
                     const media = await (0, bluebubbles_media_1.hydrateBlueBubblesAttachments)(hydrated.attachments, config, channelConfig, {
-                        preferAudioInput: providerSupportsAudioInput((0, identity_1.loadAgentConfig)().provider),
+                        preferAudioInput: providerSupportsAudioInput((0, identity_1.loadAgentConfig)().humanFacing.provider),
                     });
                     const transcriptSuffix = media.transcriptAdditions.map((entry) => `[${entry}]`).join("\n");
                     const noticeSuffix = media.notices.map((entry) => `[${entry}]`).join("\n");