@ouro.bot/cli 0.0.1-alpha.0 → 0.1.0-alpha.2

package/dist/repertoire/tasks/index.js

@@ -0,0 +1,210 @@
+"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.getTaskModule = getTaskModule;
+exports.resetTaskModule = resetTaskModule;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+const board_1 = require("./board");
+const lifecycle_1 = require("./lifecycle");
+const parser_1 = require("./parser");
+const scanner_1 = require("./scanner");
+const middleware_1 = require("./middleware");
+const transitions_1 = require("./transitions");
+function formatDate(now = new Date()) {
+    return now.toISOString().slice(0, 10);
+}
+function formatStemTimestamp(now = new Date()) {
+    const year = now.getFullYear();
+    const month = String(now.getMonth() + 1).padStart(2, "0");
+    const day = String(now.getDate()).padStart(2, "0");
+    const hours = String(now.getHours()).padStart(2, "0");
+    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)) ??
+        null);
+}
+function removeRuntimeFrontmatter(frontmatter) {
+    const { _isCanonicalFilename, ...clean } = frontmatter;
+    return clean;
+}
+class FileTaskModule {
+    scan() {
+        return (0, scanner_1.scanTasks)((0, scanner_1.getTaskRoot)());
+    }
+    getBoard() {
+        return (0, board_1.buildTaskBoard)(this.scan());
+    }
+    getTask(name) {
+        return findTask(this.scan(), name);
+    }
+    createTask(input) {
+        (0, runtime_1.emitNervesEvent)({
+            event: "mind.step_start",
+            component: "mind",
+            message: "creating task file",
+            meta: { type: input.type },
+        });
+        const type = (0, transitions_1.normalizeTaskType)(input.type);
+        if (!type) {
+            throw new Error(`invalid task type: ${input.type}`);
+        }
+        const status = (0, transitions_1.normalizeTaskStatus)(input.status ?? "drafting");
+        if (!status) {
+            throw new Error(`invalid task status: ${String(input.status)}`);
+        }
+        const collection = (0, transitions_1.canonicalCollectionForTaskType)(type);
+        const stem = `${formatStemTimestamp()}-${slugify(input.title) || "task"}`;
+        const filename = `${stem}.md`;
+        const root = (0, scanner_1.getTaskRoot)();
+        const filePath = path.join(root, collection, filename);
+        const today = formatDate();
+        const frontmatter = {
+            type,
+            category: input.category || "infrastructure",
+            title: input.title,
+            status,
+            validator: input.validator ?? null,
+            requester: input.requester ?? "agent",
+            cadence: input.cadence ?? null,
+            scheduledAt: input.scheduledAt ?? null,
+            lastRun: input.lastRun ?? null,
+            created: today,
+            updated: today,
+            child_tasks: [],
+            artifacts: [],
+        };
+        if (type === "one-shot") {
+            frontmatter.parent_task = null;
+            frontmatter.depends_on = [];
+        }
+        const content = (0, parser_1.renderTaskFile)(frontmatter, input.body);
+        const validation = (0, middleware_1.validateWrite)(filePath, content);
+        if (!validation.ok) {
+            throw new Error(validation.reason ?? "task write validation failed");
+        }
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, content, "utf-8");
+        (0, scanner_1.clearTaskScanCache)();
+        return filePath;
+    }
+    updateStatus(name, toStatus) {
+        const normalized = (0, transitions_1.normalizeTaskStatus)(toStatus);
+        if (!normalized) {
+            return { ok: false, from: "drafting", to: "drafting", reason: `invalid target status: ${toStatus}` };
+        }
+        const index = this.scan();
+        const task = findTask(index, name);
+        if (!task) {
+            return { ok: false, from: "drafting", to: normalized, reason: `task not found: ${name}` };
+        }
+        const gate = (0, middleware_1.validateStatusTransition)(task, normalized);
+        if (!gate.ok) {
+            return { ok: false, from: task.status, to: normalized, reason: gate.reason };
+        }
+        const content = fs.readFileSync(task.path, "utf-8");
+        const parsed = (0, parser_1.parseTaskFile)(content, task.path);
+        const frontmatter = removeRuntimeFrontmatter(parsed.frontmatter);
+        frontmatter.status = normalized;
+        frontmatter.updated = formatDate();
+        fs.writeFileSync(task.path, (0, parser_1.renderTaskFile)(frontmatter, parsed.body), "utf-8");
+        (0, scanner_1.clearTaskScanCache)();
+        const transition = { ok: true, from: task.status, to: normalized };
+        const afterIndex = this.scan();
+        const archive = (0, lifecycle_1.archiveCompletedTasks)(afterIndex);
+        if (archive.archived.length > 0 || archive.failures.length > 0) {
+            (0, scanner_1.clearTaskScanCache)();
+        }
+        return {
+            ...transition,
+            path: task.path,
+            archived: archive.archived,
+        };
+    }
+    validateWrite(filePath, content) {
+        return (0, middleware_1.validateWrite)(filePath, content);
+    }
+    validateTransition(from, to) {
+        return (0, transitions_1.validateTransition)(from, to);
+    }
+    validateSpawn(taskName, spawnType) {
+        const task = this.getTask(taskName);
+        if (!task) {
+            return { ok: false, reason: `task not found: ${taskName}` };
+        }
+        return (0, middleware_1.validateSpawn)(task, spawnType);
+    }
+    detectStale(thresholdDays) {
+        return (0, lifecycle_1.detectStaleTasks)(this.scan(), thresholdDays);
+    }
+    boardStatus(status) {
+        const normalized = (0, transitions_1.normalizeTaskStatus)(status);
+        if (!normalized)
+            return [];
+        return (0, board_1.boardStatus)(this.getBoard(), normalized);
+    }
+    boardAction() {
+        return (0, board_1.boardAction)(this.getBoard());
+    }
+    boardDeps() {
+        return (0, board_1.boardDeps)(this.getBoard());
+    }
+    boardSessions() {
+        return (0, board_1.boardSessions)(this.getBoard());
+    }
+}
+let taskModule = null;
+function getTaskModule() {
+    if (!taskModule) {
+        taskModule = new FileTaskModule();
+    }
+    return taskModule;
+}
+function resetTaskModule() {
+    taskModule = null;
+    (0, scanner_1.clearTaskScanCache)();
+}

package/dist/repertoire/tasks/lifecycle.js

@@ -0,0 +1,80 @@
+"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.archiveCompletedTasks = archiveCompletedTasks;
+exports.detectStaleTasks = detectStaleTasks;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+function archiveCompletedTasks(index) {
+    (0, runtime_1.emitNervesEvent)({
+        event: "mind.step_start",
+        component: "mind",
+        message: "archiving completed tasks",
+        meta: { root: index.root },
+    });
+    const archived = [];
+    const failures = [];
+    for (const task of index.tasks) {
+        if (task.status !== "done")
+            continue;
+        const archiveDir = path.join(index.root, "archive", task.collection);
+        const archiveFile = path.join(archiveDir, task.name);
+        try {
+            fs.mkdirSync(archiveDir, { recursive: true });
+            fs.renameSync(task.path, archiveFile);
+            const taskArtifactDir = task.path.replace(/\.md$/i, "");
+            if (fs.existsSync(taskArtifactDir)) {
+                fs.renameSync(taskArtifactDir, path.join(archiveDir, path.basename(taskArtifactDir)));
+            }
+            archived.push(archiveFile);
+        }
+        catch (error) {
+            failures.push(`${task.path}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return { archived, failures };
+}
+function detectStaleTasks(index, thresholdDays, now = new Date()) {
+    const staleCutoffMs = now.getTime() - thresholdDays * 24 * 60 * 60 * 1000;
+    return index.tasks.filter((task) => {
+        const updated = Date.parse(task.updated);
+        if (Number.isNaN(updated))
+            return false;
+        if (task.status === "done")
+            return false;
+        return updated < staleCutoffMs;
+    });
+}

package/dist/repertoire/tasks/middleware.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateTemplate = validateTemplate;
+exports.validateWrite = validateWrite;
+exports.validateSpawn = validateSpawn;
+exports.validateStatusTransition = validateStatusTransition;
+const runtime_1 = require("../../nerves/runtime");
+const parser_1 = require("./parser");
+const transitions_1 = require("./transitions");
+function validateTemplate(task) {
+    const required = transitions_1.TASK_REQUIRED_TEMPLATE_FIELDS[task.type];
+    const missing = required.filter((field) => !(field in task.frontmatter));
+    if (missing.length > 0) {
+        return { ok: false, reason: "missing required fields", missingFields: missing };
+    }
+    return { ok: true };
+}
+function validateWrite(filePath, content) {
+    (0, runtime_1.emitNervesEvent)({
+        event: "mind.step_start",
+        component: "mind",
+        message: "validating task write",
+        meta: { filePath },
+    });
+    const base = filePath.split(/[/\\]/).pop() ?? "";
+    if (!(0, transitions_1.isCanonicalTaskFilename)(base)) {
+        return { ok: false, reason: "non-canonical filename" };
+    }
+    try {
+        const parsed = (0, parser_1.parseTaskFile)(content, filePath);
+        return validateTemplate(parsed);
+    }
+    catch (error) {
+        return {
+            ok: false,
+            reason: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+function validateSpawn(task, spawnType) {
+    if (task.status === "done") {
+        return { ok: false, reason: "spawn-completed-path" };
+    }
+    const pipelineStage = String(task.frontmatter.pipeline_stage ?? "");
+    if (task.status === "drafting" && pipelineStage && pipelineStage !== "quality-gates") {
+        return { ok: false, reason: "spawn-coding-pipeline-stage" };
+    }
+    if (spawnType === "coding") {
+        if (task.status !== "processing" && task.status !== "collaborating") {
+            return { ok: false, reason: "spawn-coding-task-status" };
+        }
+        const hasScope = /(^|\n)##\s*scope\b/i.test(task.body);
+        if (!hasScope) {
+            return { ok: false, reason: "spawn-coding-scope-missing" };
+        }
+    }
+    return { ok: true };
+}
+function validateStatusTransition(from, toStatus) {
+    const transition = (0, transitions_1.validateTransition)(from.status, toStatus);
+    if (!transition.ok) {
+        return { ok: false, reason: transition.reason };
+    }
+    return { ok: true };
+}

package/dist/repertoire/tasks/parser.js

@@ -0,0 +1,173 @@
+"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.parseFrontmatter = parseFrontmatter;
+exports.parseTaskFile = parseTaskFile;
+exports.renderTaskFile = renderTaskFile;
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+const transitions_1 = require("./transitions");
+function parseScalar(raw) {
+    const value = raw.trim();
+    if (value === "null")
+        return null;
+    if (value === "[]")
+        return [];
+    if ((value.startsWith("\"") && value.endsWith("\"")) || (value.startsWith("'") && value.endsWith("'"))) {
+        return value.slice(1, -1);
+    }
+    return value;
+}
+function parseFrontmatter(raw) {
+    const frontmatter = {};
+    const lines = raw.split(/\r?\n/);
+    for (let idx = 0; idx < lines.length; idx += 1) {
+        const line = lines[idx];
+        if (!line.trim())
+            continue;
+        const match = /^([A-Za-z0-9_:-]+):\s*(.*)$/.exec(line);
+        if (!match)
+            continue;
+        const key = match[1];
+        const inline = match[2];
+        if (inline.length > 0) {
+            frontmatter[key] = parseScalar(inline);
+            continue;
+        }
+        const items = [];
+        let cursor = idx + 1;
+        while (cursor < lines.length && /^\s*-\s+/.test(lines[cursor])) {
+            items.push(parseScalar(lines[cursor].replace(/^\s*-\s+/, "")));
+            cursor += 1;
+        }
+        frontmatter[key] = items;
+        idx = cursor - 1;
+    }
+    return frontmatter;
+}
+function parseTaskBody(content) {
+    const lines = content.split(/\r?\n/);
+    if (lines[0]?.trim() !== "---") {
+        throw new Error("task file missing frontmatter");
+    }
+    const closing = lines.findIndex((line, index) => index > 0 && line.trim() === "---");
+    if (closing === -1) {
+        throw new Error("task file has unterminated frontmatter");
+    }
+    const rawFrontmatter = lines.slice(1, closing).join("\n");
+    const body = lines.slice(closing + 1).join("\n").trim();
+    return { frontmatter: parseFrontmatter(rawFrontmatter), body };
+}
+function collectionFromPath(taskPath, type) {
+    const parts = taskPath.split(path.sep);
+    if (parts.includes("one-shots"))
+        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) {
+    (0, runtime_1.emitNervesEvent)({
+        event: "mind.step_start",
+        component: "mind",
+        message: "parsing task file",
+        meta: { filePath },
+    });
+    const parsed = parseTaskBody(content);
+    const name = path.basename(filePath);
+    const stem = name.replace(/\.md$/i, "");
+    const type = (0, transitions_1.normalizeTaskType)(parsed.frontmatter.type);
+    const status = (0, transitions_1.normalizeTaskStatus)(parsed.frontmatter.status);
+    if (!type) {
+        throw new Error(`task file has invalid type: ${filePath}`);
+    }
+    if (!status) {
+        throw new Error(`task file has invalid status: ${filePath}`);
+    }
+    const title = String(parsed.frontmatter.title ?? stem);
+    const category = String(parsed.frontmatter.category ?? "infrastructure");
+    const created = String(parsed.frontmatter.created ?? "");
+    const updated = String(parsed.frontmatter.updated ?? created);
+    return {
+        path: filePath,
+        name,
+        stem,
+        type,
+        collection: collectionFromPath(filePath, type),
+        category,
+        title,
+        status,
+        created,
+        updated,
+        frontmatter: {
+            ...parsed.frontmatter,
+            _isCanonicalFilename: (0, transitions_1.isCanonicalTaskFilename)(name),
+        },
+        body: parsed.body,
+    };
+}
+function formatFrontmatterValue(value) {
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return ["[]"];
+        return ["", ...value.map((entry) => `- ${String(entry)}`)];
+    }
+    if (value === null)
+        return ["null"];
+    return [String(value)];
+}
+function renderTaskFile(frontmatter, body) {
+    const keys = Object.keys(frontmatter);
+    const lines = ["---"];
+    for (const key of keys) {
+        const rendered = formatFrontmatterValue(frontmatter[key]);
+        if (rendered.length === 1) {
+            lines.push(`${key}: ${rendered[0]}`);
+        }
+        else {
+            lines.push(`${key}:`);
+            for (const entry of rendered.slice(1)) {
+                lines.push(entry);
+            }
+        }
+    }
+    lines.push("---");
+    lines.push("");
+    lines.push(body.trim());
+    lines.push("");
+    return lines.join("\n");
+}

package/dist/repertoire/tasks/scanner.js

@@ -0,0 +1,132 @@
+"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.getTaskRoot = getTaskRoot;
+exports.ensureTaskLayout = ensureTaskLayout;
+exports.clearTaskScanCache = clearTaskScanCache;
+exports.scanTasks = scanTasks;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const identity_1 = require("../../heart/identity");
+const runtime_1 = require("../../nerves/runtime");
+const transitions_1 = require("./transitions");
+const parser_1 = require("./parser");
+let scanCache = null;
+function getTaskRoot() {
+    return path.join((0, identity_1.getAgentRoot)(), "tasks");
+}
+function ensureTaskLayout(root = getTaskRoot()) {
+    const dirs = [
+        root,
+        ...transitions_1.TASK_CANONICAL_COLLECTIONS.map((collection) => path.join(root, collection)),
+        path.join(root, "templates"),
+        path.join(root, ".trash"),
+        path.join(root, "archive"),
+    ];
+    for (const dir of dirs) {
+        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)) {
+                continue;
+            }
+            walkMarkdownFiles(path.join(dir, entry.name), acc);
+            continue;
+        }
+        if (entry.name.endsWith(".md")) {
+            acc.push(path.join(dir, entry.name));
+        }
+    }
+}
+function buildFingerprint(paths) {
+    const segments = paths
+        .map((filePath) => {
+        const stat = fs.statSync(filePath);
+        return `${filePath}:${stat.mtimeMs}:${stat.size}`;
+    })
+        .sort();
+    return segments.join("|");
+}
+function clearTaskScanCache() {
+    scanCache = null;
+}
+function scanTasks(root = getTaskRoot()) {
+    (0, runtime_1.emitNervesEvent)({
+        event: "mind.step_start",
+        component: "mind",
+        message: "scanning task files",
+        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);
+    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);
+        }
+        try {
+            const content = fs.readFileSync(filePath, "utf-8");
+            tasks.push((0, parser_1.parseTaskFile)(content, filePath));
+        }
+        catch (error) {
+            parseErrors.push(`${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    const index = {
+        root,
+        tasks,
+        invalidFilenames,
+        parseErrors,
+        fingerprint,
+    };
+    scanCache = { fingerprint, index };
+    return index;
+}