@ouro.bot/cli 0.1.0-alpha.580 → 0.1.0-alpha.581

package/changelog.json

@@ -1,6 +1,13 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.581",
+      "changes": [
+        "Trip ledger storage now uses git-controlled bundle-root `trips/` as canonical local storage, with copy-only import from legacy ignored `state/trips/` and divergence warnings instead of silent merges.",
+        "`ouro doctor` now checks durable trip ledgers and reports legacy-only or divergent `state/trips/` data clearly so bundle sync and backup gaps surface before travel facts are lost."
+      ]
+    },
     {
       "version": "0.1.0-alpha.580",
       "changes": [

package/dist/heart/daemon/doctor.js

@@ -373,15 +373,27 @@ function checkTrips(deps) {
         return { name: "Trips", checks };
     }
     for (const agentDir of agents) {
-        const tripsRootPath = `${deps.bundlesRoot}/${agentDir}/state/trips`;
-        if (!deps.existsSync(tripsRootPath)) {
-            // Trip ledger is optional; absence is fine. Pass with a hint.
-            checks.push({ label: `${agentDir} trip ledger`, status: "pass", detail: "no ledger directory (no trips ensured yet)" });
+        const durableTripsRoot = `${deps.bundlesRoot}/${agentDir}/trips`;
+        const legacyTripsRoot = `${deps.bundlesRoot}/${agentDir}/state/trips`;
+        const hasDurableTrips = deps.existsSync(durableTripsRoot);
+        const hasLegacyTrips = deps.existsSync(legacyTripsRoot);
+        if (!hasDurableTrips) {
+            if (hasLegacyTrips) {
+                checks.push({
+                    label: `${agentDir} trip ledger`,
+                    status: "warn",
+                    detail: "legacy state/trips exists but durable trips/ missing — run any trip tool to copy legacy storage into trips/",
+                });
+            }
+            else {
+                // Trip ledger is optional; absence is fine. Pass with a hint.
+                checks.push({ label: `${agentDir} trip ledger`, status: "pass", detail: "no ledger directory (no trips ensured yet)" });
+            }
             continue;
         }
-        const ledgerPath = `${tripsRootPath}/ledger.json`;
+        const ledgerPath = `${durableTripsRoot}/ledger.json`;
         if (!deps.existsSync(ledgerPath)) {
-            checks.push({ label: `${agentDir} trip ledger`, status: "warn", detail: "state/trips/ exists but ledger.json missing — run trip_ensure_ledger" });
+            checks.push({ label: `${agentDir} trip ledger`, status: "warn", detail: "trips/ exists but ledger.json missing — run trip_ensure_ledger" });
             continue;
         }
         let raw;
@@ -420,7 +432,7 @@ function checkTrips(deps) {
             continue;
         }
         let recordCount = 0;
-        const recordsDir = `${tripsRootPath}/records`;
+        const recordsDir = `${durableTripsRoot}/records`;
         /* v8 ignore start -- defensive: records dir presence and readdir error are filesystem-state branches not all exercised by tests; pluralization branch likewise depends on record count fixtures @preserve */
         if (deps.existsSync(recordsDir)) {
             try {
@@ -430,15 +442,50 @@ function checkTrips(deps) {
                 // ignore — the warn detail will still report 0 records
             }
         }
+        const legacyDiverges = hasLegacyTrips && tripStoresDiffer(deps, durableTripsRoot, legacyTripsRoot);
         checks.push({
             label: `${agentDir} trip ledger`,
-            status: "pass",
-            detail: `${ledgerId} (${recordCount} record${recordCount === 1 ? "" : "s"})`,
+            status: legacyDiverges ? "warn" : "pass",
+            detail: `${ledgerId} (${recordCount} record${recordCount === 1 ? "" : "s"})${legacyDiverges ? "; legacy state/trips differs from durable trips/ — durable trips/ is authoritative" : ""}`,
         });
         /* v8 ignore stop */
     }
     return { name: "Trips", checks };
 }
+function listTripStoreFiles(deps, root) {
+    const files = [];
+    if (deps.existsSync(`${root}/ledger.json`)) {
+        files.push("ledger.json");
+    }
+    const recordsDir = `${root}/records`;
+    if (deps.existsSync(recordsDir)) {
+        for (const name of deps.readdirSync(recordsDir)) {
+            if (name.endsWith(".json")) {
+                files.push(`records/${name}`);
+            }
+        }
+    }
+    return files.sort();
+}
+function tripStoresDiffer(deps, durableRoot, legacyRoot) {
+    const relativePaths = new Set([
+        ...listTripStoreFiles(deps, durableRoot),
+        ...listTripStoreFiles(deps, legacyRoot),
+    ]);
+    for (const relativePath of relativePaths) {
+        const durablePath = `${durableRoot}/${relativePath}`;
+        const legacyPath = `${legacyRoot}/${relativePath}`;
+        const durableExists = deps.existsSync(durablePath);
+        const legacyExists = deps.existsSync(legacyPath);
+        if (durableExists !== legacyExists) {
+            return true;
+        }
+        if (durableExists && deps.readFileSync(durablePath) !== deps.readFileSync(legacyPath)) {
+            return true;
+        }
+    }
+    return false;
+}
 function checkMailroom(deps) {
     const checks = [];
     const agents = discoverAgents(deps);

package/dist/trips/store.js

@@ -45,6 +45,9 @@ const identity_1 = require("../heart/identity");
 const runtime_1 = require("../nerves/runtime");
 const core_1 = require("./core");
 function tripsRoot(agentName) {
+    return path.join((0, identity_1.getAgentRoot)(agentName), "trips");
+}
+function legacyTripsRoot(agentName) {
     return path.join((0, identity_1.getAgentRoot)(agentName), "state", "trips");
 }
 function ledgerPath(agentName) {
@@ -56,6 +59,118 @@ function recordsDir(agentName) {
 function recordPath(agentName, tripId) {
     return path.join(recordsDir(agentName), `${tripId}.json`);
 }
+function ledgerPathFor(root) {
+    return path.join(root, "ledger.json");
+}
+function recordsDirFor(root) {
+    return path.join(root, "records");
+}
+function removeMigrationTempRoot(tmpRoot) {
+    const records = recordsDirFor(tmpRoot);
+    if (fs.existsSync(records)) {
+        for (const entry of fs.readdirSync(records)) {
+            fs.unlinkSync(path.join(records, entry));
+        }
+        fs.rmdirSync(records);
+    }
+    const ledger = ledgerPathFor(tmpRoot);
+    if (fs.existsSync(ledger)) {
+        fs.unlinkSync(ledger);
+    }
+    if (fs.existsSync(tmpRoot)) {
+        fs.rmdirSync(tmpRoot);
+    }
+}
+function copyLegacyTripsIfNeeded(agentName) {
+    const durableRoot = tripsRoot(agentName);
+    const legacyRoot = legacyTripsRoot(agentName);
+    if (fs.existsSync(durableRoot) || !fs.existsSync(ledgerPathFor(legacyRoot))) {
+        return;
+    }
+    const tmpRoot = `${durableRoot}.tmp-${process.pid}-${Date.now()}`;
+    removeMigrationTempRoot(tmpRoot);
+    try {
+        fs.mkdirSync(recordsDirFor(tmpRoot), { recursive: true });
+        fs.copyFileSync(ledgerPathFor(legacyRoot), ledgerPathFor(tmpRoot));
+        const legacyRecordsDir = recordsDirFor(legacyRoot);
+        if (fs.existsSync(legacyRecordsDir)) {
+            for (const entry of fs.readdirSync(legacyRecordsDir)) {
+                if (entry.endsWith(".json")) {
+                    fs.copyFileSync(path.join(legacyRecordsDir, entry), path.join(recordsDirFor(tmpRoot), entry));
+                }
+            }
+        }
+        fs.renameSync(tmpRoot, durableRoot);
+    }
+    catch (error) {
+        removeMigrationTempRoot(tmpRoot);
+        throw error;
+    }
+}
+function collectStoreFiles(root) {
+    const files = [];
+    if (fs.existsSync(ledgerPathFor(root))) {
+        files.push("ledger.json");
+    }
+    const records = recordsDirFor(root);
+    if (fs.existsSync(records)) {
+        for (const entry of fs.readdirSync(records)) {
+            if (entry.endsWith(".json")) {
+                files.push(`records/${entry}`);
+            }
+        }
+    }
+    return files.sort();
+}
+function fileAt(root, relativePath) {
+    return path.join(root, ...relativePath.split("/"));
+}
+function findLegacyDifferences(durableRoot, legacyRoot) {
+    const paths = new Set([...collectStoreFiles(durableRoot), ...collectStoreFiles(legacyRoot)]);
+    const differences = [];
+    for (const relativePath of [...paths].sort()) {
+        const durablePath = fileAt(durableRoot, relativePath);
+        const legacyPath = fileAt(legacyRoot, relativePath);
+        const durableExists = fs.existsSync(durablePath);
+        const legacyExists = fs.existsSync(legacyPath);
+        if (durableExists !== legacyExists) {
+            differences.push(relativePath);
+            continue;
+        }
+        if (durableExists && !fs.readFileSync(durablePath).equals(fs.readFileSync(legacyPath))) {
+            differences.push(relativePath);
+        }
+    }
+    return differences;
+}
+function reportLegacyDivergence(agentName) {
+    const durableRoot = tripsRoot(agentName);
+    const legacyRoot = legacyTripsRoot(agentName);
+    if (!fs.existsSync(durableRoot) || !fs.existsSync(legacyRoot)) {
+        return;
+    }
+    const differences = findLegacyDifferences(durableRoot, legacyRoot);
+    if (differences.length === 0) {
+        return;
+    }
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "trips",
+        event: "trips.legacy_diverged",
+        message: "legacy trip store differs from durable trip store",
+        meta: {
+            agentId: agentName,
+            durablePath: "trips",
+            legacyPath: "state/trips",
+            differenceCount: differences.length,
+            differences: differences.slice(0, 10),
+        },
+    });
+}
+function prepareTripStorage(agentName) {
+    copyLegacyTripsIfNeeded(agentName);
+    reportLegacyDivergence(agentName);
+}
 function readJsonFile(filePath) {
     if (!fs.existsSync(filePath))
         return null;
@@ -79,6 +194,7 @@ exports.TripNotFoundError = TripNotFoundError;
  * generate a fresh keypair and persist both halves.
  */
 function ensureAgentTripLedger(input) {
+    prepareTripStorage(input.agentName);
     const existing = readJsonFile(ledgerPath(input.agentName));
     if (existing) {
         return { ledger: existing.ledger, added: false };
@@ -103,6 +219,7 @@ function ensureAgentTripLedger(input) {
     return { ledger: created.ledger, added: true };
 }
 function readLedgerOrThrow(agentName) {
+    prepareTripStorage(agentName);
     const stored = readJsonFile(ledgerPath(agentName));
     if (!stored) {
         throw new Error(`no trip ledger for agent ${agentName} — call ensureAgentTripLedger first`);
@@ -129,6 +246,7 @@ function upsertTripRecord(agentName, trip) {
     });
 }
 function readTripRecord(agentName, tripId) {
+    prepareTripStorage(agentName);
     const payload = readJsonFile(recordPath(agentName, tripId));
     if (!payload)
         throw new TripNotFoundError({ agentName, tripId });
@@ -136,6 +254,7 @@ function readTripRecord(agentName, tripId) {
     return (0, core_1.decryptTripRecord)(payload, stored.privateKeyPem);
 }
 function listTripIds(agentName) {
+    prepareTripStorage(agentName);
     const dir = recordsDir(agentName);
     if (!fs.existsSync(dir))
         return [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.580",
+  "version": "0.1.0-alpha.581",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",