@ouro.bot/cli 0.1.0-alpha.66 → 0.1.0-alpha.661

package/dist/arc/evolution.js

@@ -0,0 +1,487 @@
+"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.nextEvolutionActionForStatus = nextEvolutionActionForStatus;
+exports.createEvolutionCase = createEvolutionCase;
+exports.readEvolutionCase = readEvolutionCase;
+exports.listEvolutionCases = listEvolutionCases;
+exports.listOpenEvolutionCases = listOpenEvolutionCases;
+exports.summarizeOpenEvolutionCases = summarizeOpenEvolutionCases;
+exports.readEvolutionTrace = readEvolutionTrace;
+exports.appendEvolutionTraceEvent = appendEvolutionTraceEvent;
+exports.findOpenEvolutionCaseByFrictionSignature = findOpenEvolutionCaseByFrictionSignature;
+exports.addEvolutionEvidence = addEvolutionEvidence;
+exports.setEvolutionBudget = setEvolutionBudget;
+exports.setEvolutionAuthority = setEvolutionAuthority;
+exports.evaluateEvolutionAction = evaluateEvolutionAction;
+exports.consumeEvolutionBudget = consumeEvolutionBudget;
+exports.recordEvolutionDecision = recordEvolutionDecision;
+exports.recordEvolutionVerification = recordEvolutionVerification;
+exports.recordEvolutionDelivery = recordEvolutionDelivery;
+exports.recordEvolutionRatification = recordEvolutionRatification;
+exports.closeEvolutionCase = closeEvolutionCase;
+exports.blockEvolutionCase = blockEvolutionCase;
+exports.deferEvolutionCase = deferEvolutionCase;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const runtime_1 = require("../nerves/runtime");
+const json_store_1 = require("./json-store");
+const TERMINAL_STATUSES = new Set(["closed", "blocked", "deferred"]);
+const ALL_ACTIONS = [
+    "create_case",
+    "add_evidence",
+    "write_record",
+    "write_desk",
+    "write_diary",
+    "spawn_coding",
+    "create_branch",
+    "commit",
+    "open_pr",
+    "merge_pr",
+    "release_publish",
+    "install_local",
+    "mutate_shared_skill",
+    "mutate_identity",
+    "mutate_voice",
+    "mutate_credentials",
+    "mutate_provider_config",
+    "send_external_message",
+    "change_hosted_infra",
+    "ratify",
+];
+const HUMAN_REQUIRED_ACTIONS = new Set([
+    "release_publish",
+    "mutate_identity",
+    "mutate_voice",
+    "mutate_credentials",
+    "mutate_provider_config",
+    "send_external_message",
+    "change_hosted_infra",
+]);
+const ASK_BEFORE_ACTIONS = new Set([
+    "merge_pr",
+    "install_local",
+    "mutate_shared_skill",
+]);
+function nowIso() {
+    return new Date().toISOString();
+}
+function evolutionDir(agentRoot) {
+    return path.join(agentRoot, "arc", "evolution");
+}
+function casesDir(agentRoot) {
+    return path.join(evolutionDir(agentRoot), "cases");
+}
+function tracesDir(agentRoot) {
+    return path.join(evolutionDir(agentRoot), "traces");
+}
+function traceFile(agentRoot, caseId) {
+    return path.join(tracesDir(agentRoot), `${caseId}.jsonl`);
+}
+function budgetForProfile(profile, updatedAt, reason) {
+    const limits = profile === "capture"
+        ? { codingSessions: 0, codingRestarts: 0, prAttempts: 0, mergeAttempts: 0, releaseInstallAttempts: 0 }
+        : profile === "trusted-local"
+            ? { codingSessions: 2, codingRestarts: 1, prAttempts: 1, mergeAttempts: 1, releaseInstallAttempts: 0 }
+            : { codingSessions: 1, codingRestarts: 0, prAttempts: 1, mergeAttempts: 0, releaseInstallAttempts: 0 };
+    return {
+        profile,
+        limits,
+        spent: {
+            codingSessions: 0,
+            codingRestarts: 0,
+            prAttempts: 0,
+            mergeAttempts: 0,
+            releaseInstallAttempts: 0,
+        },
+        updatedAt,
+        reason,
+    };
+}
+function defaultAuthority(updatedAt) {
+    const actions = {};
+    for (const action of ALL_ACTIONS) {
+        actions[action] = HUMAN_REQUIRED_ACTIONS.has(action)
+            ? "human_required"
+            : ASK_BEFORE_ACTIONS.has(action)
+                ? "ask_before_action"
+                : "allowed";
+    }
+    return {
+        actions,
+        updatedAt,
+        reason: "default conservative evolution authority",
+    };
+}
+function isEvolutionCase(value) {
+    return Boolean(value)
+        && typeof value.id === "string"
+        && typeof value.title === "string"
+        && typeof value.status === "string"
+        && typeof value.problemStatement === "string"
+        && typeof value.desiredBehavior === "string";
+}
+function writeCase(agentRoot, item) {
+    (0, json_store_1.writeJsonFile)(casesDir(agentRoot), item.id, item);
+    return item;
+}
+function updateCase(agentRoot, caseId, update) {
+    const existing = readEvolutionCase(agentRoot, caseId);
+    if (!existing) {
+        throw new Error(`Evolution case not found: ${caseId}`);
+    }
+    const updated = update({ ...existing, updatedAt: nowIso() });
+    writeCase(agentRoot, updated);
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.evolution_case_updated",
+        message: "evolution case updated",
+        meta: { caseId, status: updated.status },
+    });
+    return updated;
+}
+function appendTrace(agentRoot, event) {
+    fs.mkdirSync(tracesDir(agentRoot), { recursive: true });
+    fs.appendFileSync(traceFile(agentRoot, event.caseId), `${JSON.stringify(event)}\n`, "utf-8");
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.evolution_trace_appended",
+        message: "evolution trace event appended",
+        meta: { caseId: event.caseId, type: event.type },
+    });
+    return event;
+}
+function nextEvolutionActionForStatus(status) {
+    switch (status) {
+        case "noticed":
+        case "capturing":
+            return "scope and budget the case";
+        case "scoped":
+            return "set authority and budget";
+        case "budgeted":
+            return "decide whether to delegate or ask";
+        case "delegating":
+            return "monitor delegated coding work";
+        case "verifying":
+            return "verify against the original objective";
+        case "waiting_for_merge":
+            return "review merge authority and PR state";
+        case "updating_runtime":
+            return "verify release or local install state";
+        case "ratifying":
+            return "land or record ratification";
+        case "evaluating":
+            return "record recurrence or improvement evidence";
+        case "closed":
+            return "no action";
+        case "blocked":
+            return "resolve blocker or authority gap";
+        case "deferred":
+            return "resume only when the deferral condition changes";
+    }
+}
+function isTerminal(item) {
+    return TERMINAL_STATUSES.has(item.status);
+}
+function budgetExhausted(item, action) {
+    if (action === "spawn_coding")
+        return item.budget.spent.codingSessions >= item.budget.limits.codingSessions;
+    if (action === "open_pr")
+        return item.budget.spent.prAttempts >= item.budget.limits.prAttempts;
+    if (action === "merge_pr")
+        return item.budget.spent.mergeAttempts >= item.budget.limits.mergeAttempts;
+    if (action === "release_publish" || action === "install_local") {
+        return item.budget.spent.releaseInstallAttempts >= item.budget.limits.releaseInstallAttempts;
+    }
+    return false;
+}
+function spendBudget(item, action) {
+    const budget = {
+        ...item.budget,
+        spent: { ...item.budget.spent },
+        updatedAt: nowIso(),
+    };
+    if (action === "spawn_coding")
+        budget.spent.codingSessions += 1;
+    if (action === "open_pr")
+        budget.spent.prAttempts += 1;
+    if (action === "merge_pr")
+        budget.spent.mergeAttempts += 1;
+    if (action === "release_publish" || action === "install_local")
+        budget.spent.releaseInstallAttempts += 1;
+    return budget;
+}
+function createEvolutionCase(agentRoot, input) {
+    const timestamp = nowIso();
+    const item = {
+        id: (0, json_store_1.generateTimestampId)("evo"),
+        agentId: input.agentId ?? null,
+        title: input.title,
+        status: "noticed",
+        origin: input.origin,
+        problemStatement: input.problemStatement,
+        desiredBehavior: input.desiredBehavior,
+        evidenceRefs: input.evidenceRefs ?? [],
+        authority: defaultAuthority(timestamp),
+        budget: budgetForProfile(input.budgetProfile ?? "conservative", timestamp, "default budget"),
+        decision: null,
+        ...(input.packetId ? { packetId: input.packetId } : {}),
+        ...(input.obligationId ? { obligationId: input.obligationId } : {}),
+        ...(input.frictionSignature ? { frictionSignature: input.frictionSignature } : {}),
+        delegationRefs: [],
+        verification: null,
+        delivery: {},
+        ratification: null,
+        createdAt: timestamp,
+        updatedAt: timestamp,
+        closedAt: null,
+        latestNote: null,
+    };
+    writeCase(agentRoot, item);
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.evolution_case_created",
+        message: "evolution case created",
+        meta: { caseId: item.id, status: item.status },
+    });
+    appendEvolutionTraceEvent(agentRoot, item.id, { type: "noticed", reason: "case created" });
+    return item;
+}
+function readEvolutionCase(agentRoot, caseId) {
+    const item = (0, json_store_1.readJsonFile)(casesDir(agentRoot), caseId);
+    return item && isEvolutionCase(item) ? item : null;
+}
+function listEvolutionCases(agentRoot) {
+    return (0, json_store_1.readJsonDir)(casesDir(agentRoot))
+        .filter(isEvolutionCase)
+        .sort((left, right) => left.createdAt.localeCompare(right.createdAt));
+}
+function listOpenEvolutionCases(agentRoot) {
+    return listEvolutionCases(agentRoot).filter((item) => !isTerminal(item));
+}
+function summarizeOpenEvolutionCases(agentRoot) {
+    return listOpenEvolutionCases(agentRoot).map((item) => ({
+        id: item.id,
+        title: item.title,
+        status: item.status,
+        nextAction: nextEvolutionActionForStatus(item.status),
+        budgetProfile: item.budget.profile,
+    }));
+}
+function readEvolutionTrace(agentRoot, caseId) {
+    try {
+        const raw = fs.readFileSync(traceFile(agentRoot, caseId), "utf-8");
+        return raw
+            .split("\n")
+            .filter((line) => line.trim().length > 0)
+            .flatMap((line) => {
+            try {
+                const parsed = JSON.parse(line);
+                return parsed.caseId === caseId && typeof parsed.type === "string" ? [parsed] : [];
+            }
+            catch {
+                return [];
+            }
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function appendEvolutionTraceEvent(agentRoot, caseId, input) {
+    return appendTrace(agentRoot, {
+        id: (0, json_store_1.generateTimestampId)("evt"),
+        caseId,
+        occurredAt: nowIso(),
+        ...input,
+    });
+}
+function findOpenEvolutionCaseByFrictionSignature(agentRoot, signature) {
+    return listOpenEvolutionCases(agentRoot).find((item) => item.frictionSignature === signature) ?? null;
+}
+function addEvolutionEvidence(agentRoot, caseId, evidence) {
+    const updated = updateCase(agentRoot, caseId, (item) => ({
+        ...item,
+        evidenceRefs: [...item.evidenceRefs, evidence],
+    }));
+    appendEvolutionTraceEvent(agentRoot, caseId, {
+        type: "evidence_added",
+        reason: evidence.reason,
+        evidenceRefs: [evidence.locator],
+    });
+    return updated;
+}
+function setEvolutionBudget(agentRoot, caseId, input) {
+    const updated = updateCase(agentRoot, caseId, (item) => ({
+        ...item,
+        status: item.status === "noticed" || item.status === "capturing" || item.status === "scoped" ? "budgeted" : item.status,
+        budget: budgetForProfile(input.profile, nowIso(), input.reason),
+    }));
+    appendEvolutionTraceEvent(agentRoot, caseId, { type: "budget_set", reason: input.reason });
+    return updated;
+}
+function setEvolutionAuthority(agentRoot, caseId, input) {
+    const updated = updateCase(agentRoot, caseId, (item) => ({
+        ...item,
+        authority: {
+            actions: { ...item.authority.actions, ...input.actions },
+            updatedAt: nowIso(),
+            reason: input.reason,
+        },
+    }));
+    appendEvolutionTraceEvent(agentRoot, caseId, { type: "authority_set", reason: input.reason });
+    return updated;
+}
+function evaluateEvolutionAction(agentRoot, caseId, action) {
+    const item = readEvolutionCase(agentRoot, caseId);
+    if (!item)
+        return { allowed: false, code: "case_not_found", reason: `Evolution case not found: ${caseId}` };
+    if (isTerminal(item))
+        return { allowed: false, code: "terminal_case", reason: `Evolution case is ${item.status}` };
+    const authority = item.authority.actions[action] ?? "human_required";
+    if (authority !== "allowed")
+        return { allowed: false, code: authority, reason: `${action} is ${authority}` };
+    if (budgetExhausted(item, action))
+        return { allowed: false, code: "budget_exhausted", reason: `${action} budget is exhausted` };
+    return { allowed: true, code: "allowed", reason: `${action} allowed` };
+}
+function consumeEvolutionBudget(agentRoot, caseId, action, input) {
+    const decision = evaluateEvolutionAction(agentRoot, caseId, action);
+    if (!decision.allowed) {
+        appendEvolutionTraceEvent(agentRoot, caseId, {
+            type: "delegation_blocked",
+            reason: decision.reason,
+            ...(input.target ? { target: input.target } : {}),
+        });
+        (0, runtime_1.emitNervesEvent)({
+            component: "engine",
+            event: "engine.evolution_budget_blocked",
+            message: "evolution budget or authority blocked action",
+            meta: { caseId, action, code: decision.code },
+        });
+        throw new Error(`Evolution ${action} blocked: ${decision.reason}`);
+    }
+    const updated = updateCase(agentRoot, caseId, (item) => ({
+        ...item,
+        budget: spendBudget(item, action),
+    }));
+    appendEvolutionTraceEvent(agentRoot, caseId, {
+        type: action === "spawn_coding" ? "delegated" : "budget_set",
+        reason: input.reason,
+        ...(input.target ? { target: input.target } : {}),
+    });
+    return updated;
+}
+function recordEvolutionDecision(agentRoot, caseId, input) {
+    const decidedAt = nowIso();
+    const updated = updateCase(agentRoot, caseId, (item) => ({
+        ...item,
+        decision: { ...input, decidedAt },
+    }));
+    appendEvolutionTraceEvent(agentRoot, caseId, { type: "decision_recorded", reason: input.reason });
+    return updated;
+}
+function recordEvolutionVerification(agentRoot, caseId, input) {
+    const updated = updateCase(agentRoot, caseId, (item) => ({
+        ...item,
+        status: input.status === "passed" ? "ratifying" : "verifying",
+        verification: input,
+    }));
+    appendEvolutionTraceEvent(agentRoot, caseId, {
+        type: "verification_recorded",
+        reason: `verification ${input.status}`,
+        evidenceRefs: input.evidenceRefs,
+    });
+    return updated;
+}
+function recordEvolutionDelivery(agentRoot, caseId, input) {
+    const updated = updateCase(agentRoot, caseId, (item) => ({
+        ...item,
+        delivery: { ...item.delivery, ...input },
+    }));
+    appendEvolutionTraceEvent(agentRoot, caseId, { type: "delivery_recorded", reason: "delivery state recorded" });
+    return updated;
+}
+function recordEvolutionRatification(agentRoot, caseId, input) {
+    const updated = updateCase(agentRoot, caseId, (item) => ({
+        ...item,
+        status: item.status === "closed" ? item.status : "ratifying",
+        ratification: input,
+    }));
+    appendEvolutionTraceEvent(agentRoot, caseId, {
+        type: "ratification_recorded",
+        reason: input.reason,
+        evidenceRefs: [input.locator],
+    });
+    return updated;
+}
+function closeEvolutionCase(agentRoot, caseId, input) {
+    const closedAt = nowIso();
+    const updated = updateCase(agentRoot, caseId, (item) => {
+        const ratification = input.ratification ?? item.ratification;
+        if (!ratification) {
+            throw new Error("Evolution case closure requires ratification or none_needed");
+        }
+        return {
+            ...item,
+            status: "closed",
+            ratification,
+            closedAt,
+            latestNote: input.reason,
+        };
+    });
+    appendEvolutionTraceEvent(agentRoot, caseId, { type: "closed", reason: input.reason });
+    return updated;
+}
+function blockEvolutionCase(agentRoot, caseId, input) {
+    const updated = updateCase(agentRoot, caseId, (item) => ({
+        ...item,
+        status: "blocked",
+        latestNote: input.reason,
+        closedAt: nowIso(),
+    }));
+    appendEvolutionTraceEvent(agentRoot, caseId, { type: "blocked", reason: input.reason });
+    return updated;
+}
+function deferEvolutionCase(agentRoot, caseId, input) {
+    const updated = updateCase(agentRoot, caseId, (item) => ({
+        ...item,
+        status: "deferred",
+        latestNote: input.reason,
+        closedAt: nowIso(),
+    }));
+    appendEvolutionTraceEvent(agentRoot, caseId, { type: "deferred", reason: input.reason });
+    return updated;
+}