@ouro.bot/cli 0.1.0-alpha.56 → 0.1.0-alpha.560

package/dist/arc/obligations.js

@@ -0,0 +1,237 @@
+"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.isOpenObligationStatus = isOpenObligationStatus;
+exports.isOpenObligation = isOpenObligation;
+exports.createObligation = createObligation;
+exports.readObligations = readObligations;
+exports.readPendingObligations = readPendingObligations;
+exports.advanceObligation = advanceObligation;
+exports.fulfillObligation = fulfillObligation;
+exports.findPendingObligationForOrigin = findPendingObligationForOrigin;
+exports.enrichObligation = enrichObligation;
+exports.generateObligationId = generateObligationId;
+exports.getReturnObligationsDir = getReturnObligationsDir;
+exports.createReturnObligation = createReturnObligation;
+exports.readReturnObligation = readReturnObligation;
+exports.advanceReturnObligation = advanceReturnObligation;
+exports.listActiveReturnObligations = listActiveReturnObligations;
+const path = __importStar(require("path"));
+const identity_1 = require("../heart/identity");
+const runtime_1 = require("../nerves/runtime");
+const json_store_1 = require("./json-store");
+function obligationsDir(agentRoot) {
+    return path.join(agentRoot, "arc", "obligations");
+}
+function isOpenObligationStatus(status) {
+    return status !== "fulfilled";
+}
+function isOpenObligation(obligation) {
+    return isOpenObligationStatus(obligation.status);
+}
+function createObligation(agentRoot, input) {
+    const now = new Date().toISOString();
+    const id = (0, json_store_1.generateTimestampId)();
+    const obligation = {
+        id,
+        origin: input.origin,
+        ...(input.bridgeId ? { bridgeId: input.bridgeId } : {}),
+        content: input.content,
+        status: "pending",
+        createdAt: now,
+        updatedAt: now,
+    };
+    (0, json_store_1.writeJsonFile)(obligationsDir(agentRoot), id, obligation);
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.obligation_created",
+        message: "obligation created",
+        meta: {
+            obligationId: id,
+            friendId: input.origin.friendId,
+            channel: input.origin.channel,
+            key: input.origin.key,
+        },
+    });
+    return obligation;
+}
+function readObligations(agentRoot) {
+    const all = (0, json_store_1.readJsonDir)(obligationsDir(agentRoot));
+    return all.filter((parsed) => typeof parsed.id === "string" && typeof parsed.content === "string");
+}
+function readPendingObligations(agentRoot) {
+    return readObligations(agentRoot).filter(isOpenObligation);
+}
+function advanceObligation(agentRoot, obligationId, update) {
+    const dir = obligationsDir(agentRoot);
+    const obligation = (0, json_store_1.readJsonFile)(dir, obligationId);
+    if (!obligation)
+        return;
+    const previousStatus = obligation.status;
+    if (update.status) {
+        obligation.status = update.status;
+        if (update.status === "fulfilled") {
+            obligation.fulfilledAt = new Date().toISOString();
+        }
+    }
+    if (update.currentSurface) {
+        obligation.currentSurface = update.currentSurface;
+    }
+    if (typeof update.currentArtifact === "string") {
+        obligation.currentArtifact = update.currentArtifact;
+    }
+    if (typeof update.nextAction === "string") {
+        obligation.nextAction = update.nextAction;
+    }
+    if (typeof update.latestNote === "string") {
+        obligation.latestNote = update.latestNote;
+    }
+    obligation.updatedAt = new Date().toISOString();
+    (0, json_store_1.writeJsonFile)(dir, obligationId, obligation);
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.obligation_advanced",
+        message: "obligation advanced",
+        meta: {
+            obligationId,
+            previousStatus,
+            status: obligation.status,
+            friendId: obligation.origin.friendId,
+            channel: obligation.origin.channel,
+            key: obligation.origin.key,
+            surfaceKind: obligation.currentSurface?.kind ?? null,
+            surfaceLabel: obligation.currentSurface?.label ?? null,
+        },
+    });
+}
+function fulfillObligation(agentRoot, obligationId) {
+    advanceObligation(agentRoot, obligationId, { status: "fulfilled" });
+    const obligation = (0, json_store_1.readJsonFile)(obligationsDir(agentRoot), obligationId);
+    if (!obligation)
+        return;
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.obligation_fulfilled",
+        message: "obligation fulfilled",
+        meta: {
+            obligationId,
+            friendId: obligation.origin.friendId,
+            channel: obligation.origin.channel,
+            key: obligation.origin.key,
+        },
+    });
+}
+function findPendingObligationForOrigin(agentRoot, origin) {
+    return readPendingObligations(agentRoot).find((ob) => ob.origin.friendId === origin.friendId
+        && ob.origin.channel === origin.channel
+        && ob.origin.key === origin.key);
+}
+function enrichObligation(agentRoot, id, meaning) {
+    const dir = obligationsDir(agentRoot);
+    const existing = (0, json_store_1.readJsonFile)(dir, id);
+    if (!existing) {
+        throw new Error(`Obligation not found: ${id}`);
+    }
+    const obligation = existing;
+    obligation.meaning = meaning;
+    obligation.updatedAt = new Date().toISOString();
+    (0, json_store_1.writeJsonFile)(dir, id, obligation);
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.obligation_enriched",
+        message: "obligation enriched with meaning",
+        meta: {
+            obligationId: id,
+            salience: meaning.salience,
+            stalenessClass: meaning.stalenessClass,
+        },
+    });
+    return obligation;
+}
+function generateObligationId(timestamp) {
+    return `${timestamp}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function getReturnObligationsDir(agentName) {
+    return path.join((0, identity_1.getAgentRoot)(agentName), "arc", "obligations", "inner");
+}
+function createReturnObligation(agentName, obligation) {
+    const dir = getReturnObligationsDir(agentName);
+    (0, json_store_1.writeJsonFile)(dir, obligation.id, obligation);
+    const filePath = path.join(dir, `${obligation.id}.json`);
+    (0, runtime_1.emitNervesEvent)({
+        event: "mind.obligation_created",
+        component: "mind",
+        message: "return obligation created",
+        meta: {
+            obligationId: obligation.id,
+            origin: `${obligation.origin.friendId}/${obligation.origin.channel}/${obligation.origin.key}`,
+            status: obligation.status,
+        },
+    });
+    return filePath;
+}
+function readReturnObligation(agentName, obligationId) {
+    return (0, json_store_1.readJsonFile)(getReturnObligationsDir(agentName), obligationId);
+}
+function advanceReturnObligation(agentName, obligationId, update) {
+    const existing = readReturnObligation(agentName, obligationId);
+    if (!existing)
+        return null;
+    const updated = {
+        ...existing,
+        status: update.status,
+        ...(update.startedAt !== undefined ? { startedAt: update.startedAt } : {}),
+        ...(update.returnedAt !== undefined ? { returnedAt: update.returnedAt } : {}),
+        ...(update.returnTarget !== undefined ? { returnTarget: update.returnTarget } : {}),
+    };
+    (0, json_store_1.writeJsonFile)(getReturnObligationsDir(agentName), obligationId, updated);
+    (0, runtime_1.emitNervesEvent)({
+        event: "mind.obligation_advanced",
+        component: "mind",
+        message: `obligation advanced to ${update.status}`,
+        meta: {
+            obligationId,
+            status: update.status,
+            ...(update.returnTarget ? { returnTarget: update.returnTarget } : {}),
+        },
+    });
+    return updated;
+}
+function listActiveReturnObligations(agentName) {
+    const all = (0, json_store_1.readJsonDir)(getReturnObligationsDir(agentName));
+    return all
+        .filter((parsed) => parsed.status === "queued" || parsed.status === "running")
+        .sort((a, b) => a.createdAt - b.createdAt);
+}

package/dist/arc/packets.js

@@ -0,0 +1,193 @@
+"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.getPonderPacketArtifactsDir = getPonderPacketArtifactsDir;
+exports.listPonderPackets = listPonderPackets;
+exports.readPonderPacket = readPonderPacket;
+exports.createPonderPacket = createPonderPacket;
+exports.revisePonderPacket = revisePonderPacket;
+exports.advancePonderPacket = advancePonderPacket;
+exports.findHarnessFrictionPacket = findHarnessFrictionPacket;
+const path = __importStar(require("path"));
+const runtime_1 = require("../nerves/runtime");
+const task_lifecycle_1 = require("./task-lifecycle");
+const json_store_1 = require("./json-store");
+function packetsDir(agentRoot) {
+    return path.join(agentRoot, "arc", "packets");
+}
+function getPonderPacketArtifactsDir(agentRoot, packetId) {
+    return path.join(agentRoot, "state", "packets", packetId);
+}
+function packetSop(kind) {
+    switch (kind) {
+        case "harness_friction":
+            return "harness_friction_v1";
+        case "research":
+            return "research_v1";
+        case "reflection":
+            return "reflection_v1";
+    }
+}
+function isPacketKind(value) {
+    return value === "harness_friction" || value === "research" || value === "reflection";
+}
+function isPonderPacket(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const packet = value;
+    return typeof packet.id === "string"
+        && isPacketKind(packet.kind)
+        && typeof packet.objective === "string"
+        && typeof packet.summary === "string"
+        && Array.isArray(packet.successCriteria)
+        && (0, task_lifecycle_1.isTaskStatus)(packet.status)
+        && typeof packet.createdAt === "number"
+        && typeof packet.updatedAt === "number";
+}
+function listPonderPackets(agentRoot) {
+    return (0, json_store_1.readJsonDir)(packetsDir(agentRoot))
+        .filter(isPonderPacket)
+        .sort((left, right) => left.createdAt - right.createdAt);
+}
+function readPonderPacket(agentRoot, packetId) {
+    const packet = (0, json_store_1.readJsonFile)(packetsDir(agentRoot), packetId);
+    return isPonderPacket(packet) ? packet : null;
+}
+function createPonderPacket(agentRoot, input) {
+    const now = Date.now();
+    const packet = {
+        id: (0, json_store_1.generateTimestampId)("pkt"),
+        kind: input.kind,
+        sop: packetSop(input.kind),
+        status: "drafting",
+        objective: input.objective,
+        summary: input.summary,
+        successCriteria: input.successCriteria,
+        ...(input.origin ? { origin: input.origin } : {}),
+        ...(input.relatedObligationId ? { relatedObligationId: input.relatedObligationId } : {}),
+        ...(input.relatedReturnObligationId ? { relatedReturnObligationId: input.relatedReturnObligationId } : {}),
+        ...(input.followsPacketId ? { followsPacketId: input.followsPacketId } : {}),
+        payload: input.payload,
+        createdAt: now,
+        updatedAt: now,
+    };
+    (0, json_store_1.writeJsonFile)(packetsDir(agentRoot), packet.id, packet);
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.packet_created",
+        message: "ponder packet created",
+        meta: { packetId: packet.id, kind: packet.kind, status: packet.status },
+    });
+    return packet;
+}
+function revisePonderPacket(agentRoot, packetId, input) {
+    const existing = readPonderPacket(agentRoot, packetId);
+    if (!existing) {
+        throw new Error(`packet not found: ${packetId}`);
+    }
+    if (existing.status !== "drafting") {
+        throw new Error("packet is no longer drafting; file a follow-up packet instead");
+    }
+    const revised = {
+        ...existing,
+        kind: input.kind,
+        sop: packetSop(input.kind),
+        objective: input.objective,
+        summary: input.summary,
+        successCriteria: input.successCriteria,
+        payload: input.payload,
+        updatedAt: Date.now(),
+    };
+    (0, json_store_1.writeJsonFile)(packetsDir(agentRoot), packetId, revised);
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.packet_revised",
+        message: "ponder packet revised",
+        meta: { packetId, kind: revised.kind, status: revised.status },
+    });
+    return revised;
+}
+function advancePonderPacket(agentRoot, packetId, update) {
+    const existing = readPonderPacket(agentRoot, packetId);
+    if (!existing) {
+        throw new Error(`packet not found: ${packetId}`);
+    }
+    const nextStatus = update.status ?? existing.status;
+    if (update.status) {
+        const transition = (0, task_lifecycle_1.validateTransition)(existing.status, update.status);
+        if (!transition.ok) {
+            throw new Error(transition.reason);
+        }
+    }
+    const advanced = {
+        ...existing,
+        status: nextStatus,
+        ...(update.relatedObligationId ? { relatedObligationId: update.relatedObligationId } : {}),
+        ...(update.relatedReturnObligationId ? { relatedReturnObligationId: update.relatedReturnObligationId } : {}),
+        updatedAt: Date.now(),
+    };
+    (0, json_store_1.writeJsonFile)(packetsDir(agentRoot), packetId, advanced);
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.packet_advanced",
+        message: "ponder packet advanced",
+        meta: { packetId, status: advanced.status },
+    });
+    return advanced;
+}
+function findHarnessFrictionPacket(agentRoot, origin, frictionSignature) {
+    const found = listPonderPackets(agentRoot).find((packet) => {
+        if (packet.kind !== "harness_friction")
+            return false;
+        if (!packet.origin)
+            return false;
+        return packet.origin.friendId === origin.friendId
+            && packet.origin.channel === origin.channel
+            && packet.origin.key === origin.key
+            && packet.payload.frictionSignature === frictionSignature;
+    }) ?? null;
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.packet_lookup",
+        message: "ponder packet lookup completed",
+        meta: {
+            kind: "harness_friction",
+            found: found !== null,
+            origin: `${origin.friendId}/${origin.channel}/${origin.key}`,
+            frictionSignature,
+        },
+    });
+    return found;
+}

package/dist/arc/presence.js

@@ -0,0 +1,185 @@
+"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.derivePresence = derivePresence;
+exports.writePresence = writePresence;
+exports.readPresence = readPresence;
+exports.readPeerPresence = readPeerPresence;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../nerves/runtime");
+function presenceDir(agentRoot) {
+    return path.join(agentRoot, "state", "presence");
+}
+function deriveAvailability(inputs) {
+    if (inputs.currentTempo === "crisis")
+        return "dnd";
+    if (inputs.activeSessions > 0)
+        return "active";
+    if (inputs.openObligations > 0)
+        return "idle";
+    return "away";
+}
+function deriveLane(inputs) {
+    const hasCoding = inputs.codingLanes > 0;
+    const hasBridges = inputs.activeBridges > 0;
+    if (hasCoding && hasBridges)
+        return "mixed";
+    if (hasCoding)
+        return "coding";
+    if (hasBridges)
+        return "conversation";
+    return "idle";
+}
+function deriveMission(inputs) {
+    const parts = [];
+    if (inputs.openObligations > 0) {
+        parts.push(`${inputs.openObligations} open obligation${inputs.openObligations !== 1 ? "s" : ""}`);
+    }
+    if (inputs.activeBridges > 0) {
+        parts.push(`${inputs.activeBridges} active bridge${inputs.activeBridges !== 1 ? "s" : ""}`);
+    }
+    if (inputs.codingLanes > 0) {
+        parts.push(`${inputs.codingLanes} coding lane${inputs.codingLanes !== 1 ? "s" : ""}`);
+    }
+    if (parts.length === 0)
+        return "no active work";
+    return parts.join(", ");
+}
+function derivePresence(_agentRoot, agentName, inputs) {
+    const presence = {
+        agentName,
+        availability: deriveAvailability(inputs),
+        lane: deriveLane(inputs),
+        mission: deriveMission(inputs),
+        tempo: inputs.currentTempo,
+        updatedAt: new Date().toISOString(),
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.presence_derived",
+        message: `presence derived: ${presence.availability}/${presence.lane}`,
+        meta: {
+            agentName,
+            availability: presence.availability,
+            lane: presence.lane,
+            tempo: presence.tempo,
+        },
+    });
+    return presence;
+}
+function writePresence(agentRoot, _agentName, presence) {
+    const dir = presenceDir(agentRoot);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, "self.json"), JSON.stringify(presence, null, 2), "utf-8");
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.presence_written",
+        message: `presence written for ${presence.agentName}`,
+        meta: { agentName: presence.agentName },
+    });
+}
+function readPresence(agentRoot, _agentName) {
+    const filePath = path.join(presenceDir(agentRoot), "self.json");
+    if (!fs.existsSync(filePath)) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "heart",
+            event: "heart.presence_read",
+            message: "presence file not found",
+            meta: { found: false },
+        });
+        return null;
+    }
+    try {
+        const raw = fs.readFileSync(filePath, "utf-8");
+        const presence = JSON.parse(raw);
+        (0, runtime_1.emitNervesEvent)({
+            component: "heart",
+            event: "heart.presence_read",
+            message: `presence read: ${presence.availability}`,
+            meta: { agentName: presence.agentName, found: true },
+        });
+        return presence;
+    }
+    catch {
+        (0, runtime_1.emitNervesEvent)({
+            component: "heart",
+            event: "heart.presence_read_error",
+            message: "failed to read presence file",
+            meta: { error: "parse error" },
+        });
+        return null;
+    }
+}
+function readPeerPresence(agentRoot) {
+    const friendsDir = path.join(agentRoot, "friends");
+    if (!fs.existsSync(friendsDir)) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "heart",
+            event: "heart.peer_presence_read",
+            message: "no friends directory, no peers",
+            meta: { peerCount: 0 },
+        });
+        return [];
+    }
+    const files = fs.readdirSync(friendsDir).filter((f) => f.endsWith(".json"));
+    const peers = [];
+    for (const file of files) {
+        try {
+            const raw = fs.readFileSync(path.join(friendsDir, file), "utf-8");
+            const friend = JSON.parse(raw);
+            if (friend.kind !== "agent")
+                continue;
+            peers.push({
+                agentName: friend.name ?? path.basename(file, ".json"),
+                availability: "idle",
+                lane: "idle",
+                mission: "",
+                tempo: "brief",
+                updatedAt: friend.updatedAt ?? new Date().toISOString(),
+            });
+        }
+        catch {
+            // Skip malformed or unreadable files
+        }
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.peer_presence_read",
+        message: `read ${peers.length} agent peer records from friends`,
+        meta: { peerCount: peers.length },
+    });
+    return peers;
+}

package/dist/arc/task-lifecycle.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TASK_STATUS_TRANSITIONS = exports.TASK_VALID_STATUSES = void 0;
+exports.isTaskStatus = isTaskStatus;
+exports.normalizeTaskStatus = normalizeTaskStatus;
+exports.validateTransition = validateTransition;
+exports.renderTaskTransitionLines = renderTaskTransitionLines;
+const runtime_1 = require("../nerves/runtime");
+exports.TASK_VALID_STATUSES = [
+    "drafting",
+    "processing",
+    "validating",
+    "collaborating",
+    "paused",
+    "blocked",
+    "done",
+    "cancelled",
+];
+exports.TASK_STATUS_TRANSITIONS = {
+    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: [],
+};
+function isTaskStatus(value) {
+    return exports.TASK_VALID_STATUSES.includes(value);
+}
+function normalizeTaskStatus(value) {
+    if (typeof value !== "string")
+        return null;
+    const normalized = value.trim().toLowerCase();
+    return isTaskStatus(normalized) ? normalized : null;
+}
+function validateTransition(from, to) {
+    (0, runtime_1.emitNervesEvent)({
+        event: "mind.step_start",
+        component: "mind",
+        message: "validating task status transition",
+        meta: { from, to },
+    });
+    if (from === to) {
+        return { ok: true, from, to };
+    }
+    const allowed = exports.TASK_STATUS_TRANSITIONS[from];
+    if (!allowed.includes(to)) {
+        return {
+            ok: false,
+            from,
+            to,
+            reason: `invalid transition: ${from} -> ${to}`,
+        };
+    }
+    return { ok: true, from, to };
+}
+function renderTaskTransitionLines() {
+    return exports.TASK_VALID_STATUSES.map((from) => {
+        const to = exports.TASK_STATUS_TRANSITIONS[from];
+        const rendered = to.length > 0 ? to.map((next) => `\`${next}\``).join(", ") : "(terminal)";
+        return `- \`${from}\` -> ${rendered}`;
+    });
+}