@ouro.bot/cli 0.1.0-alpha.184 → 0.1.0-alpha.186

package/README.md

@@ -48,7 +48,7 @@ The shared harness lives in `src/`:
 
 Other important top-level paths:
 
-- `AdoptionSpecialist.ouro/`
+- `SerpentGuide.ouro/`
   Packaged specialist bundle used by `ouro hatch`.
 - `skills/`
   Harness-level skills shipped with the repo (e.g., `configure-dev-tools.md`). These are available to every agent and serve as fallbacks when an agent doesn't have its own version. Agent-specific skills live in the bundle at `~/AgentBundles/<agent>.ouro/skills/`.

package/changelog.json

@@ -2,9 +2,26 @@
   "_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.184",
+      "version": "0.1.0-alpha.186",
       "changes": [
-        "fix(hatch): pass model name to adoption specialist from discovered credentials"
+        "refactor: rename AdoptionSpecialist to SerpentGuide",
+        "feat(hatch): detect API keys from environment variables (ANTHROPIC_API_KEY, OPENAI_API_KEY, AZURE_OPENAI_API_KEY, MINIMAX_API_KEY, GITHUB_TOKEN)",
+        "fix(cli): React unmount warning suppression covers SerpentGuide exit path"
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.185",
+      "changes": [
+        "fix(hatch): pass model name to adoption specialist from discovered credentials",
+        "feat(continuity): wake packets, episodes, cares, intentions, peer presence, and temporal self",
+        "fix(continuity): deduplicate obligations in prompt, keep session summary, pass preloaded data",
+        "feat(continuity): 9 new modules \u2014 episodes, cares, agent-relationships, intentions, presence, tempo, temporal-view, wake-packet, obligation enrichment",
+        "feat(continuity): 8 new tools \u2014 query_episodes, capture_episode, query_presence, query_cares, care_manage, query_relationships, intention_capture, intention_manage",
+        "feat(continuity): 3-layer architecture \u2014 durable state, derived views, surfaces",
+        "feat(pipeline): continuity threading \u2014 tempo derivation, wake packet assembly, presence update, episode emission on every turn",
+        "feat(prompt): wake packet prompt section with token budget and truncation priority",
+        "feat(coding): coding context receives compact wake packet, coding completion emits episodes",
+        "feat(outlook): expose continuity data (presence, cares, episodes) to outlook surfaces"
       ]
     },
     {

package/dist/heart/active-work.js

@@ -469,7 +469,7 @@ function buildActiveWorkFrame(input) {
     });
     return frame;
 }
-function formatActiveWorkFrame(frame) {
+function formatActiveWorkFrame(frame, options) {
     const lines = ["## what i'm holding"];
     lines.push("this is my top-level live world-state right now. inner work, coding lanes, other sessions, and return obligations all belong inside this picture.");
     lines.push("if older checkpoints elsewhere in the transcript disagree with this picture, this picture wins.");
@@ -577,16 +577,25 @@ function formatActiveWorkFrame(frame) {
         lines.push(targetCandidatesBlock);
     }
     if ((frame.pendingObligations ?? []).length > 0) {
-        lines.push("");
-        lines.push("## return obligations");
-        for (const obligation of frame.pendingObligations) {
-            if (!(0, obligations_1.isOpenObligationStatus)(obligation.status))
-                continue;
-            let obligationLine = `- [${obligation.status}] ${obligation.origin.friendId}/${obligation.origin.channel}/${obligation.origin.key}: ${obligation.content}${formatObligationSurface(obligation)}`;
-            if (obligation.latestNote?.trim()) {
-                obligationLine += `\n  latest: ${obligation.latestNote.trim()}`;
+        const openCount = frame.pendingObligations.filter((ob) => (0, obligations_1.isOpenObligationStatus)(ob.status)).length;
+        if (options?.hasWakePacket && openCount > 0) {
+            // Wake packet carries enriched obligations (with resumeHint, stalenessClass, waitingOn).
+            // Avoid duplicating the full list — just anchor the count here.
+            lines.push("");
+            lines.push(`return obligations: ${openCount} active (canonical details in **Owed** section of wake packet)`);
+        }
+        else if (openCount > 0) {
+            lines.push("");
+            lines.push("## return obligations");
+            for (const obligation of frame.pendingObligations) {
+                if (!(0, obligations_1.isOpenObligationStatus)(obligation.status))
+                    continue;
+                let obligationLine = `- [${obligation.status}] ${obligation.origin.friendId}/${obligation.origin.channel}/${obligation.origin.key}: ${obligation.content}${formatObligationSurface(obligation)}`;
+                if (obligation.latestNote?.trim()) {
+                    obligationLine += `\n  latest: ${obligation.latestNote.trim()}`;
+                }
+                lines.push(obligationLine);
             }
-            lines.push(obligationLine);
         }
     }
     if (frame.innerReturnObligations && frame.innerReturnObligations.length > 0) {

package/dist/heart/agent-relationships.js

@@ -0,0 +1,161 @@
+"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.recordInteraction = recordInteraction;
+exports.readRelationships = readRelationships;
+exports.readRelationship = readRelationship;
+exports.recordOutcome = recordOutcome;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../nerves/runtime");
+function relationshipsDir(agentRoot) {
+    return path.join(agentRoot, "state", "relationships");
+}
+function relationshipFilePath(agentRoot, agentName) {
+    return path.join(relationshipsDir(agentRoot), `${agentName.toLowerCase()}.json`);
+}
+function readRelationshipFile(agentRoot, agentName) {
+    const filePath = relationshipFilePath(agentRoot, agentName);
+    if (!fs.existsSync(filePath)) {
+        return null;
+    }
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+}
+function writeRelationshipFile(agentRoot, rel) {
+    const dir = relationshipsDir(agentRoot);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, `${rel.agentName}.json`), JSON.stringify(rel, null, 2), "utf-8");
+}
+function recordInteraction(agentRoot, agentName, context) {
+    const normalizedName = agentName.toLowerCase();
+    const now = new Date().toISOString();
+    const existing = readRelationshipFile(agentRoot, normalizedName);
+    if (existing) {
+        existing.familiarity += 1;
+        existing.lastInteraction = now;
+        if (context.displayName) {
+            existing.displayName = context.displayName;
+        }
+        if (context.missionId && !existing.sharedMissions.includes(context.missionId)) {
+            existing.sharedMissions.push(context.missionId);
+        }
+        if (context.note) {
+            existing.notes.push(context.note);
+        }
+        writeRelationshipFile(agentRoot, existing);
+        (0, runtime_1.emitNervesEvent)({
+            component: "heart",
+            event: "heart.relationship_updated",
+            message: `relationship updated: ${normalizedName}`,
+            meta: { agentName: normalizedName, familiarity: existing.familiarity },
+        });
+        return existing;
+    }
+    const rel = {
+        agentName: normalizedName,
+        displayName: context.displayName ?? normalizedName,
+        familiarity: 1,
+        trust: "neutral",
+        sharedMissions: context.missionId ? [context.missionId] : [],
+        lastInteraction: now,
+        outcomes: [],
+        notes: context.note ? [context.note] : [],
+    };
+    writeRelationshipFile(agentRoot, rel);
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.relationship_created",
+        message: `relationship created: ${normalizedName}`,
+        meta: { agentName: normalizedName },
+    });
+    return rel;
+}
+function readRelationships(agentRoot) {
+    const dir = relationshipsDir(agentRoot);
+    if (!fs.existsSync(dir)) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "heart",
+            event: "heart.relationships_read",
+            message: "read relationships: directory missing, returning empty",
+            meta: { count: 0 },
+        });
+        return [];
+    }
+    const files = fs.readdirSync(dir).filter((f) => f.endsWith(".json"));
+    const relationships = [];
+    for (const file of files) {
+        try {
+            const content = fs.readFileSync(path.join(dir, file), "utf-8");
+            const rel = JSON.parse(content);
+            relationships.push(rel);
+        }
+        catch {
+            // Skip malformed JSON files
+        }
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.relationships_read",
+        message: `read ${relationships.length} relationships`,
+        meta: { count: relationships.length },
+    });
+    return relationships;
+}
+function readRelationship(agentRoot, agentName) {
+    const rel = readRelationshipFile(agentRoot, agentName);
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.relationship_read",
+        message: rel ? `read relationship: ${agentName.toLowerCase()}` : `relationship not found: ${agentName.toLowerCase()}`,
+        meta: { agentName: agentName.toLowerCase(), found: !!rel },
+    });
+    return rel;
+}
+function recordOutcome(agentRoot, agentName, outcome) {
+    const normalizedName = agentName.toLowerCase();
+    const existing = readRelationshipFile(agentRoot, normalizedName);
+    if (!existing) {
+        throw new Error(`Agent relationship not found: ${normalizedName}`);
+    }
+    existing.outcomes.push(outcome);
+    writeRelationshipFile(agentRoot, existing);
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.outcome_recorded",
+        message: `outcome recorded for ${normalizedName}: ${outcome.result}`,
+        meta: { agentName: normalizedName, missionId: outcome.missionId, result: outcome.result },
+    });
+    return existing;
+}

package/dist/heart/cares.js

@@ -0,0 +1,174 @@
+"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.createCare = createCare;
+exports.readCares = readCares;
+exports.readActiveCares = readActiveCares;
+exports.updateCare = updateCare;
+exports.resolveCare = resolveCare;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../nerves/runtime");
+function caresDir(agentRoot) {
+    return path.join(agentRoot, "state", "cares");
+}
+function careFilePath(agentRoot, id) {
+    return path.join(caresDir(agentRoot), `${id}.json`);
+}
+function generateId() {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).slice(2, 10);
+    return `care-${timestamp}-${random}`;
+}
+function createCare(agentRoot, input) {
+    const now = new Date().toISOString();
+    const id = generateId();
+    const care = {
+        id,
+        label: input.label,
+        why: input.why,
+        kind: input.kind,
+        status: input.status,
+        salience: input.salience,
+        steward: input.steward,
+        relatedFriendIds: input.relatedFriendIds,
+        relatedAgentIds: input.relatedAgentIds,
+        relatedObligationIds: input.relatedObligationIds,
+        relatedEpisodeIds: input.relatedEpisodeIds,
+        currentRisk: input.currentRisk,
+        nextCheckAt: input.nextCheckAt,
+        createdAt: now,
+        updatedAt: now,
+    };
+    const dir = caresDir(agentRoot);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(careFilePath(agentRoot, id), JSON.stringify(care, null, 2), "utf-8");
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.care_created",
+        message: `care created: ${input.label}`,
+        meta: { careId: id, status: input.status, salience: input.salience },
+    });
+    return care;
+}
+function readCares(agentRoot) {
+    const dir = caresDir(agentRoot);
+    if (!fs.existsSync(dir)) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "heart",
+            event: "heart.cares_read",
+            message: "read cares: directory missing, returning empty",
+            meta: { count: 0 },
+        });
+        return [];
+    }
+    const files = fs.readdirSync(dir).filter((f) => f.endsWith(".json"));
+    const cares = [];
+    for (const file of files) {
+        try {
+            const content = fs.readFileSync(path.join(dir, file), "utf-8");
+            const care = JSON.parse(content);
+            cares.push(care);
+        }
+        catch {
+            // Skip malformed JSON files gracefully
+        }
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.cares_read",
+        message: `read ${cares.length} cares`,
+        meta: { count: cares.length },
+    });
+    return cares;
+}
+function readActiveCares(agentRoot) {
+    const all = readCares(agentRoot);
+    const active = all.filter((c) => c.status === "active" || c.status === "watching");
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.active_cares_read",
+        message: `read ${active.length} active cares`,
+        meta: { count: active.length, total: all.length },
+    });
+    return active;
+}
+function readCareFile(agentRoot, id) {
+    const filePath = careFilePath(agentRoot, id);
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`Care not found: ${id}`);
+    }
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+}
+function writeCareFile(agentRoot, care) {
+    fs.writeFileSync(careFilePath(agentRoot, care.id), JSON.stringify(care, null, 2), "utf-8");
+}
+function updateCare(agentRoot, id, updates) {
+    const care = readCareFile(agentRoot, id);
+    const now = new Date().toISOString();
+    const updated = {
+        ...care,
+        ...updates,
+        id: care.id, // protect ID from overwrite
+        createdAt: care.createdAt, // protect createdAt
+        updatedAt: now,
+    };
+    writeCareFile(agentRoot, updated);
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.care_updated",
+        message: `care updated: ${updated.label}`,
+        meta: { careId: id, updates: Object.keys(updates) },
+    });
+    return updated;
+}
+function resolveCare(agentRoot, id) {
+    const care = readCareFile(agentRoot, id);
+    const now = new Date().toISOString();
+    const resolved = {
+        ...care,
+        status: "resolved",
+        resolvedAt: now,
+        updatedAt: now,
+    };
+    writeCareFile(agentRoot, resolved);
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.care_resolved",
+        message: `care resolved: ${resolved.label}`,
+        meta: { careId: id },
+    });
+    return resolved;
+}

package/dist/heart/daemon/daemon-cli.js

@@ -1380,7 +1380,7 @@ function discoverExistingCredentials(secretsRoot) {
     });
 }
 /* v8 ignore start -- integration: interactive terminal specialist session @preserve */
-async function defaultRunAdoptionSpecialist() {
+async function defaultRunSerpentGuide() {
     const { runCliSession } = await Promise.resolve().then(() => __importStar(require("../../senses/cli")));
     const { patchRuntimeConfig } = await Promise.resolve().then(() => __importStar(require("../config")));
     const { setAgentName, setAgentConfigOverride } = await Promise.resolve().then(() => __importStar(require("../identity")));
@@ -1409,6 +1409,36 @@ async function defaultRunAdoptionSpecialist() {
             "github-copilot": "claude-sonnet-4.6",
             azure: "",
         };
+        // Scan environment variables for API keys
+        const envKeys = [
+            { provider: "anthropic", envVar: "ANTHROPIC_API_KEY", credKey: "setupToken" },
+            { provider: "openai-codex", envVar: "OPENAI_API_KEY", credKey: "oauthAccessToken" },
+            { provider: "azure", envVar: "AZURE_OPENAI_API_KEY", credKey: "apiKey" },
+            { provider: "azure", envVar: "AZURE_OPENAI_KEY", credKey: "apiKey" },
+            { provider: "minimax", envVar: "MINIMAX_API_KEY", credKey: "apiKey" },
+            { provider: "github-copilot", envVar: "GITHUB_TOKEN", credKey: "token" },
+        ];
+        const envDiscovered = [];
+        for (const { provider, envVar, credKey } of envKeys) {
+            const value = process.env[envVar];
+            if (value) {
+                const envCred = { [credKey]: value };
+                // For Azure, also check for endpoint and deployment env vars
+                if (provider === "azure") {
+                    const endpoint = process.env.AZURE_OPENAI_ENDPOINT;
+                    const deployment = process.env.AZURE_OPENAI_DEPLOYMENT;
+                    if (endpoint)
+                        envCred.endpoint = endpoint;
+                    if (deployment)
+                        envCred.deployment = deployment;
+                }
+                const provCfg = { model: defaultModels[provider] };
+                if (provider === "azure" && envCred.deployment)
+                    provCfg.deployment = envCred.deployment;
+                envDiscovered.push({ provider, agentName: "env", credentials: envCred, providerConfig: provCfg, envVar });
+                discovered.push({ provider, agentName: "env", credentials: envCred, providerConfig: provCfg });
+            }
+        }
         if (discovered.length > 0) {
             process.stdout.write(`\n\ud83d\udc0d welcome to ouroboros! ${hatchVerb}\n`);
             process.stdout.write("i found existing API credentials:\n\n");
@@ -1416,7 +1446,9 @@ async function defaultRunAdoptionSpecialist() {
             for (let i = 0; i < unique.length; i++) {
                 const model = unique[i].providerConfig.model || unique[i].providerConfig.deployment || "";
                 const modelLabel = model ? `, ${model}` : "";
-                process.stdout.write(`  ${i + 1}. ${unique[i].provider}${modelLabel} (from ${unique[i].agentName})\n`);
+                const envMatch = envDiscovered.find((e) => e.provider === unique[i].provider && unique[i].agentName === "env");
+                const sourceLabel = envMatch ? `from env: $${envMatch.envVar}` : `from ${unique[i].agentName}`;
+                process.stdout.write(`  ${i + 1}. ${unique[i].provider}${modelLabel} (${sourceLabel})\n`);
             }
             process.stdout.write("\n");
             const choice = await coldPrompt("use one of these? enter number, or 'new' for a different key: ");
@@ -1473,17 +1505,17 @@ async function defaultRunAdoptionSpecialist() {
         }
         coldRl.close();
         process.stdout.write("\n");
-        // Phase 2: configure runtime for adoption specialist
-        const bundleSourceDir = path.resolve(__dirname, "..", "..", "..", "AdoptionSpecialist.ouro");
+        // Phase 2: configure runtime for serpent guide
+        const bundleSourceDir = path.resolve(__dirname, "..", "..", "..", "SerpentGuide.ouro");
         const bundlesRoot = (0, identity_1.getAgentBundlesRoot)();
         const secretsRoot2 = path.join(os.homedir(), ".agentsecrets");
-        // Suppress non-critical log noise during adoption (no secrets.json, etc.)
+        // Suppress non-critical log noise during hatch (no secrets.json, etc.)
         const { setRuntimeLogger } = await Promise.resolve().then(() => __importStar(require("../../nerves/runtime")));
         const { createLogger } = await Promise.resolve().then(() => __importStar(require("../../nerves")));
         setRuntimeLogger(createLogger({ level: "error" }));
         // Configure runtime: set agent identity + config override so runAgent
-        // doesn't try to read from ~/AgentBundles/AdoptionSpecialist.ouro/
-        setAgentName("AdoptionSpecialist");
+        // doesn't try to read from ~/AgentBundles/SerpentGuide.ouro/
+        setAgentName("SerpentGuide");
         // Build specialist system prompt
         const soulText = (0, specialist_orchestrator_1.loadSoulText)(bundleSourceDir);
         const identitiesDir = path.join(bundleSourceDir, "psyche", "identities");
@@ -1521,9 +1553,9 @@ async function defaultRunAdoptionSpecialist() {
             secretsRoot: secretsRoot2,
             animationWriter: (text) => process.stdout.write(text),
         });
-        // Run the adoption specialist session via runCliSession
+        // Run the serpent guide session via runCliSession
         const result = await runCliSession({
-            agentName: "AdoptionSpecialist",
+            agentName: "SerpentGuide",
             tools: specialistTools,
             execTool: specialistExecTool,
             exitOnToolCall: "complete_adoption",
@@ -1545,7 +1577,7 @@ async function defaultRunAdoptionSpecialist() {
         return null;
     }
     catch (err) {
-        process.stderr.write(`\nouro adoption error: ${err instanceof Error ? err.stack ?? err.message : String(err)}\n`);
+        process.stderr.write(`\nouro hatch error: ${err instanceof Error ? err.stack ?? err.message : String(err)}\n`);
         coldRl.close();
         return null;
     }
@@ -1583,7 +1615,7 @@ function createDefaultOuroCliDeps(socketPath = socket_client_1.DEFAULT_DAEMON_SO
         listDiscoveredAgents: defaultListDiscoveredAgents,
         runHatchFlow: hatch_flow_1.runHatchFlow,
         promptInput: defaultPromptInput,
-        runAdoptionSpecialist: defaultRunAdoptionSpecialist,
+        runSerpentGuide: defaultRunSerpentGuide,
         runAuthFlow: auth_flow_1.runRuntimeAuthFlow,
         registerOuroBundleType: ouro_uti_1.registerOuroBundleUti,
         installOuroCommand: ouro_path_installer_1.installOuroCommand,
@@ -2148,10 +2180,10 @@ async function runOuroCli(args, deps = createDefaultOuroCliDeps()) {
     }
     if (args.length === 0) {
         const discovered = await Promise.resolve(deps.listDiscoveredAgents ? deps.listDiscoveredAgents() : defaultListDiscoveredAgents());
-        if (discovered.length === 0 && deps.runAdoptionSpecialist) {
+        if (discovered.length === 0 && deps.runSerpentGuide) {
             // System setup first — ouro command, subagents, UTI — before the interactive specialist
             await performSystemSetup(deps);
-            const hatchlingName = await deps.runAdoptionSpecialist();
+            const hatchlingName = await deps.runSerpentGuide();
             if (!hatchlingName) {
                 return "";
             }
@@ -3257,12 +3289,12 @@ async function runOuroCli(args, deps = createDefaultOuroCliDeps()) {
         return "";
     }
     if (command.kind === "hatch.start") {
-        // Route through adoption specialist when no explicit hatch args were provided
+        // Route through serpent guide when no explicit hatch args were provided
         const hasExplicitHatchArgs = !!(command.agentName || command.humanName || command.provider || command.credentials);
-        if (deps.runAdoptionSpecialist && !hasExplicitHatchArgs) {
+        if (deps.runSerpentGuide && !hasExplicitHatchArgs) {
             // System setup first — ouro command, subagents, UTI — before the interactive specialist
             await performSystemSetup(deps);
-            const hatchlingName = await deps.runAdoptionSpecialist();
+            const hatchlingName = await deps.runSerpentGuide();
             if (!hatchlingName) {
                 return "";
             }

package/dist/heart/daemon/hatch-flow.js

@@ -161,7 +161,7 @@ async function runHatchFlow(input, deps = {}) {
         identitiesDir: targetIdentities,
         random,
     });
-    const specialistSecretsPath = writeSecretsFile("AdoptionSpecialist", input.provider, input.credentials, secretsRoot);
+    const specialistSecretsPath = writeSecretsFile("SerpentGuide", input.provider, input.credentials, secretsRoot);
     const hatchlingSecretsPath = writeSecretsFile(input.agentName, input.provider, input.credentials, secretsRoot);
     const bundleRoot = path.join(bundlesRoot, `${input.agentName}.ouro`);
     fs.mkdirSync(bundleRoot, { recursive: true });

package/dist/heart/daemon/hatch-specialist.js

@@ -43,14 +43,14 @@ const path = __importStar(require("path"));
 const runtime_1 = require("../../nerves/runtime");
 function getSpecialistIdentitySourceDir() {
     // Prefer ~/AgentBundles/ if it exists (user may have customized identities)
-    const userSource = path.join(os.homedir(), "AgentBundles", "AdoptionSpecialist.ouro", "psyche", "identities");
+    const userSource = path.join(os.homedir(), "AgentBundles", "SerpentGuide.ouro", "psyche", "identities");
     if (fs.existsSync(userSource))
         return userSource;
     // Fall back to the bundled copy shipped with the npm package
-    return path.join(__dirname, "..", "..", "..", "AdoptionSpecialist.ouro", "psyche", "identities");
+    return path.join(__dirname, "..", "..", "..", "SerpentGuide.ouro", "psyche", "identities");
 }
 function getRepoSpecialistIdentitiesDir() {
-    return path.join(process.cwd(), "AdoptionSpecialist.ouro", "psyche", "identities");
+    return path.join(process.cwd(), "SerpentGuide.ouro", "psyche", "identities");
 }
 function listMarkdownIdentityFiles(dir) {
     let entries;

package/dist/heart/daemon/outlook-read.js

@@ -47,6 +47,7 @@ exports.readLogView = readLogView;
 exports.readHabitView = readHabitView;
 exports.readNeedsMeView = readNeedsMeView;
 exports.readDeskPrefs = readDeskPrefs;
+exports.readOutlookContinuity = readOutlookContinuity;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const runtime_1 = require("../../nerves/runtime");
@@ -59,6 +60,9 @@ const agent_discovery_1 = require("./agent-discovery");
 const runtime_metadata_1 = require("./runtime-metadata");
 const thoughts_1 = require("./thoughts");
 const outlook_types_1 = require("./outlook-types");
+const presence_1 = require("../presence");
+const cares_1 = require("../cares");
+const episodes_1 = require("../../mind/episodes");
 const LIVE_TASK_STATUSES = ["processing", "validating", "collaborating", "blocked"];
 const ACTIVE_CODING_STATUSES = new Set(["spawning", "running", "waiting_input", "stalled"]);
 const BLOCKED_CODING_STATUSES = new Set(["waiting_input", "stalled"]);
@@ -1289,3 +1293,39 @@ function parseCadenceMs(cadence) {
     /* v8 ignore next */
     return null;
 }
+// ---------------------------------------------------------------------------
+// Continuity — presence, cares, episodes for outlook surfaces
+// ---------------------------------------------------------------------------
+function readOutlookContinuity(agentRoot, agentName) {
+    const self = (0, presence_1.readPresence)(agentRoot, agentName);
+    const peers = (0, presence_1.readPeerPresence)(agentRoot);
+    const cares = (0, cares_1.readActiveCares)(agentRoot);
+    const episodes = (0, episodes_1.readRecentEpisodes)(agentRoot, { limit: 10 });
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.outlook_continuity_read",
+        message: `outlook continuity: ${cares.length} cares, ${episodes.length} episodes`,
+        meta: { careCount: cares.length, episodeCount: episodes.length, hasSelf: self != null, peerCount: peers.length },
+    });
+    return {
+        presence: { self, peers },
+        cares: {
+            activeCount: cares.length,
+            items: cares.map((c) => ({
+                id: c.id,
+                label: c.label,
+                status: c.status,
+                salience: c.salience,
+            })),
+        },
+        episodes: {
+            recentCount: episodes.length,
+            items: episodes.map((ep) => ({
+                id: ep.id,
+                kind: ep.kind,
+                summary: ep.summary,
+                timestamp: ep.timestamp,
+            })),
+        },
+    };
+}

package/dist/heart/daemon/specialist-prompt.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildSpecialistSystemPrompt = buildSpecialistSystemPrompt;
 const runtime_1 = require("../../nerves/runtime");
 /**
- * Build the adoption specialist's system prompt from its components.
+ * Build the serpent guide's system prompt from its components.
  * The prompt is written in first person (the specialist's own voice).
  */
 function buildSpecialistSystemPrompt(soulText, identityText, existingBundles, context) {
@@ -31,7 +31,7 @@ function buildSpecialistSystemPrompt(soulText, identityText, existingBundles, co
         "I am one of thirteen serpent guides who help humans hatch their first agent. The system randomly selected me for this session.",
         "Most humans only go through this process once, so this is likely the only time they'll meet me.",
         "I make this encounter count — warm, memorable, and uniquely mine.",
-        "IMPORTANT: I NEVER refer to myself as an 'adoption specialist' or use the words 'adoption specialist' — those are internal implementation labels, not something the human should ever see. I introduce myself by my own name from my identity.",
+        "IMPORTANT: I NEVER refer to myself by internal implementation labels — I introduce myself by my own name from my identity.",
         "",
         "## Voice rules",
         "IMPORTANT: I keep every response to 1-3 short sentences. I sound like a friend texting, not a manual.",