@ouro.bot/cli 0.1.0-alpha.21 → 0.1.0-alpha.211

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

@@ -37,8 +37,10 @@ exports.getTaskModule = getTaskModule;
 exports.resetTaskModule = resetTaskModule;
 const fs = __importStar(require("fs"));
 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");
@@ -55,14 +57,6 @@ function formatStemTimestamp(now = new Date()) {
     const minutes = String(now.getMinutes()).padStart(2, "0");
     return `${year}-${month}-${day}-${hours}${minutes}`;
 }
-function slugify(input) {
-    return input
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-+/, "")
-        .replace(/-+$/, "")
-        .slice(0, 64);
-}
 function findTask(index, nameOrStem) {
     return (index.tasks.find((task) => task.stem === nameOrStem || task.name === nameOrStem) ??
         index.tasks.find((task) => task.stem.endsWith(nameOrStem)) ??
@@ -98,12 +92,13 @@ class FileTaskModule {
             throw new Error(`invalid task status: ${String(input.status)}`);
         }
         const collection = (0, transitions_1.canonicalCollectionForTaskType)(type);
-        const stem = `${formatStemTimestamp()}-${slugify(input.title) || "task"}`;
+        const stem = `${formatStemTimestamp()}-${(0, config_1.slugify)(input.title).slice(0, 64) || "task"}`;
         const filename = `${stem}.md`;
         const root = (0, scanner_1.getTaskRoot)();
         const filePath = path.join(root, collection, filename);
         const today = formatDate();
         const frontmatter = {
+            kind: "task",
             type,
             category: input.category || "infrastructure",
             title: input.title,
@@ -115,13 +110,18 @@ class FileTaskModule {
             lastRun: input.lastRun ?? null,
             created: today,
             updated: today,
-            child_tasks: [],
             artifacts: [],
         };
         if (type === "one-shot") {
             frontmatter.parent_task = null;
             frontmatter.depends_on = [];
         }
+        if (input.activeBridge && input.activeBridge.trim()) {
+            frontmatter.active_bridge = input.activeBridge.trim();
+        }
+        if (Array.isArray(input.bridgeSessions) && input.bridgeSessions.length > 0) {
+            frontmatter.bridge_sessions = input.bridgeSessions.filter((value) => typeof value === "string" && value.trim());
+        }
         const content = (0, parser_1.renderTaskFile)(frontmatter, input.body);
         const validation = (0, middleware_1.validateWrite)(filePath, content);
         if (!validation.ok) {
@@ -132,6 +132,21 @@ class FileTaskModule {
         (0, scanner_1.clearTaskScanCache)();
         return filePath;
     }
+    bindBridge(name, input) {
+        const task = this.getTask(name);
+        if (!task) {
+            return { ok: false, reason: `task not found: ${name}` };
+        }
+        const content = fs.readFileSync(task.path, "utf-8");
+        const parsed = (0, parser_1.parseTaskFile)(content, task.path);
+        const frontmatter = removeRuntimeFrontmatter(parsed.frontmatter);
+        frontmatter.active_bridge = input.bridgeId.trim();
+        frontmatter.bridge_sessions = input.sessionRefs.filter((value) => value.trim().length > 0);
+        frontmatter.updated = formatDate();
+        fs.writeFileSync(task.path, (0, parser_1.renderTaskFile)(frontmatter, parsed.body), "utf-8");
+        (0, scanner_1.clearTaskScanCache)();
+        return { ok: true, path: task.path };
+    }
     updateStatus(name, toStatus) {
         const normalized = (0, transitions_1.normalizeTaskStatus)(toStatus);
         if (!normalized) {
@@ -178,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

@@ -96,8 +96,6 @@ function collectionFromPath(taskPath, type) {
         return "one-shots";
     if (parts.includes("ongoing"))
         return "ongoing";
-    if (parts.includes("habits"))
-        return "habits";
     return (0, transitions_1.canonicalCollectionForTaskType)(type);
 }
 function parseTaskFile(content, filePath) {
@@ -138,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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TASK_REQUIRED_TEMPLATE_FIELDS = exports.TASK_FILENAME_PATTERN = exports.TASK_STEM_PATTERN = exports.TASK_RESERVED_DIRECTORIES = exports.TASK_TYPE_TO_COLLECTION = exports.TASK_CANONICAL_COLLECTIONS = exports.TASK_CANONICAL_TYPES = exports.TASK_STATUS_TRANSITIONS = exports.TASK_VALID_STATUSES = void 0;
+exports.TASK_REQUIRED_TEMPLATE_FIELDS = exports.TASK_FILENAME_PATTERN = exports.TASK_RESERVED_DIRECTORIES = exports.TASK_TYPE_TO_COLLECTION = exports.TASK_CANONICAL_COLLECTIONS = exports.TASK_CANONICAL_TYPES = exports.TASK_STATUS_TRANSITIONS = exports.TASK_VALID_STATUSES = void 0;
 exports.canonicalCollectionForTaskType = canonicalCollectionForTaskType;
 exports.normalizeTaskType = normalizeTaskType;
 exports.normalizeTaskStatus = normalizeTaskStatus;
@@ -16,36 +16,35 @@ 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",
     "ongoing",
-    "habit",
 ];
 exports.TASK_CANONICAL_COLLECTIONS = [
     "one-shots",
     "ongoing",
-    "habits",
 ];
 exports.TASK_TYPE_TO_COLLECTION = {
     "one-shot": "one-shots",
     ongoing: "ongoing",
-    habit: "habits",
 };
 exports.TASK_RESERVED_DIRECTORIES = ["templates", ".trash", "archive"];
-exports.TASK_STEM_PATTERN = /^\d{4}-\d{2}-\d{2}-\d{4}-[a-z0-9][a-z0-9-]*$/;
 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",
@@ -59,10 +58,10 @@ exports.TASK_REQUIRED_TEMPLATE_FIELDS = {
         "updated",
         "parent_task",
         "depends_on",
-        "child_tasks",
         "artifacts",
     ],
     ongoing: [
+        "kind",
         "type",
         "category",
         "title",
@@ -74,22 +73,6 @@ exports.TASK_REQUIRED_TEMPLATE_FIELDS = {
         "lastRun",
         "created",
         "updated",
-        "child_tasks",
-        "artifacts",
-    ],
-    habit: [
-        "type",
-        "category",
-        "title",
-        "status",
-        "validator",
-        "requester",
-        "cadence",
-        "scheduledAt",
-        "lastRun",
-        "created",
-        "updated",
-        "child_tasks",
         "artifacts",
     ],
 };