@ouro.bot/cli 0.1.0-alpha.48 → 0.1.0-alpha.481

package/dist/repertoire/stripe-client.js

@@ -0,0 +1,131 @@
+"use strict";
+/**
+ * Thin wrapper around the Stripe Issuing API.
+ *
+ * Initializes with a restricted API key from the agent's vault.
+ * Card numbers are NEVER included in nerves events or log output.
+ * The `getCardDetails` method exists only for internal payment flows
+ * (e.g., passing card details to Duffel) — the returned data must
+ * never escape the calling function's scope.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStripeClient = createStripeClient;
+const stripe_1 = __importDefault(require("stripe"));
+const credential_access_1 = require("./credential-access");
+const runtime_1 = require("../nerves/runtime");
+// ---------------------------------------------------------------------------
+// Implementation
+// ---------------------------------------------------------------------------
+function toCardInfo(card) {
+    return {
+        cardId: card.id,
+        last4: card.last4,
+        status: card.status,
+    };
+}
+/**
+ * Create a Stripe client initialized with a restricted key from the vault.
+ */
+async function createStripeClient() {
+    const store = (0, credential_access_1.getCredentialStore)();
+    const apiKey = await store.getRawSecret("stripe.com", "restrictedKey");
+    // StripeConstructor is a callable (not a class), cast the result
+    const stripe = (0, stripe_1.default)(apiKey);
+    return {
+        async createVirtualCard(opts) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.stripe_card_create_start",
+                message: "creating virtual card",
+                meta: { type: opts.type, currency: opts.currency },
+            });
+            const spendingControls = {
+                spending_limits: [
+                    {
+                        amount: opts.spendLimit * 100, // Stripe uses cents
+                        interval: opts.type === "single_use" ? "all_time" : "monthly",
+                    },
+                ],
+                ...(opts.merchantCategories
+                    ? { allowed_categories: opts.merchantCategories }
+                    : {}),
+            };
+            const card = await stripe.issuing.cards.create({
+                type: "virtual",
+                currency: opts.currency,
+                spending_controls: spendingControls,
+                status: "active",
+            });
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.stripe_card_create_end",
+                message: "virtual card created",
+                meta: { cardId: card.id, last4: card.last4 },
+            });
+            return toCardInfo(card);
+        },
+        async getCard(cardId) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.stripe_card_get",
+                message: "retrieving card info",
+                meta: { cardId },
+            });
+            const card = await stripe.issuing.cards.retrieve(cardId);
+            return toCardInfo(card);
+        },
+        async updateCard(cardId, updates) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.stripe_card_update",
+                message: "updating card",
+                meta: { cardId },
+            });
+            const card = await stripe.issuing.cards.update(cardId, updates);
+            return toCardInfo(card);
+        },
+        async deactivateCard(cardId) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.stripe_card_deactivate",
+                message: "deactivating card",
+                meta: { cardId },
+            });
+            const card = await stripe.issuing.cards.update(cardId, { status: "canceled" });
+            return toCardInfo(card);
+        },
+        async listCards() {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.stripe_cards_list",
+                message: "listing cards",
+                meta: {},
+            });
+            const result = await stripe.issuing.cards.list();
+            return result.data.map(toCardInfo);
+        },
+        async getCardDetails(cardId) {
+            // This method retrieves sensitive card details for payment flows.
+            // The data must NEVER be logged, emitted, or returned to the model.
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.stripe_card_details_get",
+                message: "retrieving card details for payment flow",
+                meta: { cardId },
+            });
+            const card = await stripe.issuing.cards.retrieve(cardId, {
+                expand: ["number", "cvc"],
+            });
+            return {
+                cardId: card.id,
+                number: card.number,
+                cvc: card.cvc,
+                expMonth: card.exp_month,
+                expYear: card.exp_year,
+            };
+        },
+    };
+}

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));
@@ -59,8 +67,26 @@ function activeSessionLines(tasks) {
     });
     return active.map((task) => task.stem).sort();
 }
+function activeBridgeLines(tasks) {
+    return tasks
+        .filter((task) => typeof task.frontmatter.active_bridge === "string" && String(task.frontmatter.active_bridge).trim())
+        .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(", ")}`);
     }
@@ -77,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)");
@@ -99,13 +130,20 @@ function buildTaskBoard(index) {
         fullLines.push("## active sessions");
         fullLines.push(active.map((line) => `- ${line}`).join("\n"));
     }
+    const activeBridges = activeBridgeLines(index.tasks);
+    if (activeBridges.length > 0) {
+        fullLines.push("## active bridges");
+        fullLines.push(activeBridges.map((line) => `- ${line}`).join("\n"));
+    }
     return {
         compact,
         full: fullLines.join("\n\n"),
         byStatus,
+        issues: index.issues,
         actionRequired: actionRequired(index, byStatus),
         unresolvedDependencies: unresolved,
         activeSessions: active,
+        activeBridges,
     };
 }
 function boardStatus(board, status) {

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

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTaskModule = createTaskModule;
 exports.getTaskModule = getTaskModule;
 exports.resetTaskModule = resetTaskModule;
 const fs = __importStar(require("fs"));
@@ -40,6 +41,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");
@@ -66,8 +68,12 @@ function removeRuntimeFrontmatter(frontmatter) {
     return clean;
 }
 class FileTaskModule {
+    root;
+    constructor(root = (0, scanner_1.getTaskRoot)()) {
+        this.root = root;
+    }
     scan() {
-        return (0, scanner_1.scanTasks)((0, scanner_1.getTaskRoot)());
+        return (0, scanner_1.scanTasks)(this.root);
     }
     getBoard() {
         return (0, board_1.buildTaskBoard)(this.scan());
@@ -93,10 +99,11 @@ class FileTaskModule {
         const collection = (0, transitions_1.canonicalCollectionForTaskType)(type);
         const stem = `${formatStemTimestamp()}-${(0, config_1.slugify)(input.title).slice(0, 64) || "task"}`;
         const filename = `${stem}.md`;
-        const root = (0, scanner_1.getTaskRoot)();
+        const root = this.root;
         const filePath = path.join(root, collection, filename);
         const today = formatDate();
         const frontmatter = {
+            kind: "task",
             type,
             category: input.category || "infrastructure",
             title: input.title,
@@ -108,13 +115,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) {
@@ -125,6 +137,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) {
@@ -171,6 +198,9 @@ class FileTaskModule {
         }
         return (0, middleware_1.validateSpawn)(task, spawnType);
     }
+    fix(options) {
+        return (0, fix_1.applyFixes)(options, this.root);
+    }
     detectStale(thresholdDays) {
         return (0, lifecycle_1.detectStaleTasks)(this.scan(), thresholdDays);
     }
@@ -191,9 +221,12 @@ class FileTaskModule {
     }
 }
 let taskModule = null;
+function createTaskModule(root = (0, scanner_1.getTaskRoot)()) {
+    return new FileTaskModule(root);
+}
 function getTaskModule() {
     if (!taskModule) {
-        taskModule = new FileTaskModule();
+        taskModule = createTaskModule();
     }
     return taskModule;
 }

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) {