@ouro.bot/cli 0.1.0-alpha.28 → 0.1.0-alpha.280

package/dist/mind/file-state.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileStateCache = exports.FileStateCache = void 0;
+exports.contentHash = contentHash;
+const crypto_1 = require("crypto");
+const fs_1 = require("fs");
+const runtime_1 = require("../nerves/runtime");
+/** Compute sha256 hex hash of content */
+function contentHash(content) {
+    return (0, crypto_1.createHash)("sha256").update(content).digest("hex");
+}
+/**
+ * Session-scoped LRU cache tracking file reads.
+ * Stores content hashes (not full content) to limit memory.
+ * Keyed by absolute file path.
+ *
+ * Also maintains a separate snapshot list for future rewind support.
+ * Snapshots are indexed by content hash and linked to conversation messages.
+ */
+class FileStateCache {
+    entries;
+    maxSize;
+    snapshots = [];
+    maxSnapshots = 100;
+    constructor(maxSize = 50) {
+        this.entries = new Map();
+        this.maxSize = maxSize;
+    }
+    /**
+     * Record a file read. Computes content hash and stores metadata.
+     */
+    record(filePath, content, mtime, offset, limit, messageId) {
+        // If key already exists, delete it so re-insertion moves it to end (most recent)
+        if (this.entries.has(filePath)) {
+            this.entries.delete(filePath);
+        }
+        const hash = contentHash(content);
+        const fullRead = offset === undefined && limit === undefined;
+        this.entries.set(filePath, {
+            hash,
+            mtime,
+            offset: fullRead ? undefined : offset,
+            limit: fullRead ? undefined : limit,
+            fullRead,
+            recordedAt: Date.now(),
+            messageId,
+        });
+        (0, runtime_1.emitNervesEvent)({
+            component: "mind",
+            event: "mind.file_state.record",
+            message: "recorded file state",
+            meta: { path: filePath, hash, fullRead },
+        });
+        // Evict LRU (first entry in Map iteration order) if over capacity
+        if (this.entries.size > this.maxSize) {
+            const firstKey = this.entries.keys().next().value;
+            this.entries.delete(firstKey);
+        }
+    }
+    /**
+     * Get the cached state for a file path. Also promotes it in LRU order.
+     */
+    get(filePath) {
+        const entry = this.entries.get(filePath);
+        if (entry === undefined)
+            return undefined;
+        // Promote to most-recently-used by re-inserting
+        this.entries.delete(filePath);
+        this.entries.set(filePath, entry);
+        (0, runtime_1.emitNervesEvent)({
+            component: "mind",
+            event: "mind.file_state.get",
+            message: "retrieved file state",
+            meta: { path: filePath, hash: entry.hash },
+        });
+        return entry;
+    }
+    /**
+     * Check if a file has been modified since the last recorded read.
+     * Uses mtime as primary signal, content hash as fallback for cloud sync / touch scenarios.
+     * Returns { stale: false } if the path is not in cache or the file cannot be stat'd.
+     */
+    isStale(filePath) {
+        const entry = this.entries.get(filePath);
+        if (entry === undefined)
+            return { stale: false };
+        let currentMtime;
+        try {
+            currentMtime = (0, fs_1.statSync)(filePath).mtimeMs;
+        }
+        catch {
+            // File doesn't exist or can't be stat'd -- no basis for staleness
+            return { stale: false };
+        }
+        // Fast path: mtime unchanged means not stale
+        if (currentMtime === entry.mtime)
+            return { stale: false };
+        // mtime differs -- check content hash as fallback (handles touch / cloud sync)
+        try {
+            const currentContent = (0, fs_1.readFileSync)(filePath, "utf-8");
+            const currentHash = contentHash(currentContent);
+            if (currentHash === entry.hash)
+                return { stale: false };
+            (0, runtime_1.emitNervesEvent)({
+                component: "mind",
+                event: "mind.file_state.stale_detected",
+                message: "file staleness detected",
+                meta: { path: filePath, previousHash: entry.hash, currentHash },
+            });
+            return { stale: true, reason: `file modified since last read (mtime and content differ)` };
+        }
+        catch {
+            // Can't read file -- treat as not stale (file may have been deleted)
+            return { stale: false };
+        }
+    }
+    /**
+     * Create a pre-edit snapshot of the current cache state for a file.
+     * Snapshots are stored separately from the LRU cache for future rewind support.
+     * Returns undefined if the path is not in cache.
+     */
+    snapshot(filePath) {
+        const entry = this.entries.get(filePath);
+        if (entry === undefined)
+            return undefined;
+        const snap = {
+            filePath,
+            hash: entry.hash,
+            mtime: entry.mtime,
+            messageId: entry.messageId,
+            createdAt: Date.now(),
+        };
+        this.snapshots.push(snap);
+        (0, runtime_1.emitNervesEvent)({
+            component: "mind",
+            event: "mind.file_state.snapshot_created",
+            message: "created file state snapshot",
+            meta: { path: filePath, hash: snap.hash },
+        });
+        // Evict oldest snapshots if over capacity
+        if (this.snapshots.length > this.maxSnapshots) {
+            this.snapshots = this.snapshots.slice(this.snapshots.length - this.maxSnapshots);
+        }
+        return snap;
+    }
+    /**
+     * Get all snapshots in creation order.
+     */
+    getSnapshots() {
+        return this.snapshots;
+    }
+    /**
+     * Look up a snapshot by content hash. Returns the first match.
+     */
+    lookupSnapshotByHash(hash) {
+        return this.snapshots.find(s => s.hash === hash);
+    }
+    /**
+     * Clear all snapshots.
+     */
+    clearSnapshots() {
+        this.snapshots = [];
+    }
+    /**
+     * Clear all cached entries (does not clear snapshots).
+     */
+    clear() {
+        (0, runtime_1.emitNervesEvent)({
+            component: "mind",
+            event: "mind.file_state.clear",
+            message: "cleared file state cache",
+            meta: { entryCount: this.entries.size },
+        });
+        this.entries.clear();
+    }
+}
+exports.FileStateCache = FileStateCache;
+/** Session-scoped singleton instance used by tool handlers */
+exports.fileStateCache = new FileStateCache();

package/dist/mind/first-impressions.js

@@ -11,9 +11,22 @@ exports.ONBOARDING_TOKEN_THRESHOLD = 100_000;
 function isOnboarding(friend) {
     return (friend.totalTokens ?? 0) < exports.ONBOARDING_TOKEN_THRESHOLD;
 }
-function getFirstImpressions(friend) {
+function hasLiveContinuityPressure(state) {
+    if (!state)
+        return false;
+    if (typeof state.currentObligation === "string" && state.currentObligation.trim().length > 0)
+        return true;
+    if (state.mustResolveBeforeHandoff === true)
+        return true;
+    if (state.hasQueuedFollowUp === true)
+        return true;
+    return false;
+}
+function getFirstImpressions(friend, state) {
     if (!isOnboarding(friend))
         return "";
+    if (hasLiveContinuityPressure(state))
+        return "";
     (0, runtime_1.emitNervesEvent)({
         component: "mind",
         event: "mind.first_impressions",

package/dist/mind/friends/channel.js

@@ -2,11 +2,26 @@
 // Channel capabilities -- hardcoded const map keyed by channel identifier.
 // Pure lookup, no I/O, cannot fail. Unknown channel gets minimal defaults.
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.channelToFacing = channelToFacing;
 exports.getChannelCapabilities = getChannelCapabilities;
+exports.isRemoteChannel = isRemoteChannel;
+exports.getAlwaysOnSenseNames = getAlwaysOnSenseNames;
 const runtime_1 = require("../../nerves/runtime");
+const AGENT_FACING_CHANNELS = new Set(["inner", "mcp"]);
+function channelToFacing(channel) {
+    const facing = channel && AGENT_FACING_CHANNELS.has(channel) ? "agent" : "human";
+    (0, runtime_1.emitNervesEvent)({
+        component: "channels",
+        event: "channel.facing_lookup",
+        message: "channel facing lookup",
+        meta: { channel: channel ?? "undefined", facing },
+    });
+    return facing;
+}
 const CHANNEL_CAPABILITIES = {
     cli: {
         channel: "cli",
+        senseType: "local",
         availableIntegrations: [],
         supportsMarkdown: false,
         supportsStreaming: true,
@@ -15,6 +30,7 @@ const CHANNEL_CAPABILITIES = {
     },
     teams: {
         channel: "teams",
+        senseType: "closed",
         availableIntegrations: ["ado", "graph", "github"],
         supportsMarkdown: true,
         supportsStreaming: true,
@@ -23,15 +39,35 @@ const CHANNEL_CAPABILITIES = {
     },
     bluebubbles: {
         channel: "bluebubbles",
+        senseType: "open",
         availableIntegrations: [],
         supportsMarkdown: false,
         supportsStreaming: false,
         supportsRichCards: false,
         maxMessageLength: Infinity,
     },
+    inner: {
+        channel: "inner",
+        senseType: "internal",
+        availableIntegrations: [],
+        supportsMarkdown: false,
+        supportsStreaming: true,
+        supportsRichCards: false,
+        maxMessageLength: Infinity,
+    },
+    mcp: {
+        channel: "mcp",
+        senseType: "local",
+        availableIntegrations: [],
+        supportsMarkdown: true,
+        supportsStreaming: false,
+        supportsRichCards: false,
+        maxMessageLength: Infinity,
+    },
 };
 const DEFAULT_CAPABILITIES = {
     channel: "cli",
+    senseType: "local",
     availableIntegrations: [],
     supportsMarkdown: false,
     supportsStreaming: false,
@@ -47,3 +83,23 @@ function getChannelCapabilities(channel) {
     });
     return CHANNEL_CAPABILITIES[channel] ?? DEFAULT_CAPABILITIES;
 }
+/** Whether the channel is remote (open or closed) vs local/internal. */
+function isRemoteChannel(capabilities) {
+    const senseType = capabilities?.senseType;
+    return senseType !== undefined && senseType !== "local" && senseType !== "internal";
+}
+/**
+ * Returns channel names whose senseType is "open" or "closed" -- i.e. channels
+ * that are always-on (daemon-managed) rather than interactive or internal.
+ */
+function getAlwaysOnSenseNames() {
+    (0, runtime_1.emitNervesEvent)({
+        component: "channels",
+        event: "channel.always_on_lookup",
+        message: "always-on sense names lookup",
+        meta: {},
+    });
+    return Object.entries(CHANNEL_CAPABILITIES)
+        .filter(([, cap]) => cap.senseType === "open" || cap.senseType === "closed")
+        .map(([channel]) => channel);
+}

package/dist/mind/friends/group-context.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upsertGroupContextParticipants = upsertGroupContextParticipants;
+const node_crypto_1 = require("node:crypto");
+const runtime_1 = require("../../nerves/runtime");
+const CURRENT_SCHEMA_VERSION = 1;
+function normalizeDisplayName(externalId, displayName) {
+    const trimmed = displayName?.trim();
+    return trimmed && trimmed.length > 0 ? trimmed : externalId;
+}
+function buildNameNotes(name, now) {
+    return name !== "Unknown"
+        ? { name: { value: name, savedAt: now } }
+        : {};
+}
+function dedupeParticipants(participants) {
+    const deduped = new Map();
+    for (const participant of participants) {
+        const externalId = participant.externalId.trim();
+        if (!externalId)
+            continue;
+        const key = `${participant.provider}:${externalId}`;
+        if (!deduped.has(key)) {
+            deduped.set(key, {
+                ...participant,
+                externalId,
+                displayName: participant.displayName?.trim() || undefined,
+            });
+        }
+    }
+    return Array.from(deduped.values());
+}
+function createGroupExternalId(provider, groupExternalId, linkedAt) {
+    return {
+        provider,
+        externalId: groupExternalId,
+        linkedAt,
+    };
+}
+function shouldPromoteToAcquaintance(friend) {
+    return (friend.trustLevel ?? "stranger") === "stranger";
+}
+function createAcquaintanceRecord(participant, groupExternalId, linkedAt) {
+    const name = normalizeDisplayName(participant.externalId, participant.displayName);
+    return {
+        id: (0, node_crypto_1.randomUUID)(),
+        name,
+        role: "acquaintance",
+        trustLevel: "acquaintance",
+        connections: [],
+        externalIds: [
+            {
+                provider: participant.provider,
+                externalId: participant.externalId,
+                linkedAt,
+            },
+            createGroupExternalId(participant.provider, groupExternalId, linkedAt),
+        ],
+        tenantMemberships: [],
+        toolPreferences: {},
+        notes: buildNameNotes(name, linkedAt),
+        totalTokens: 0,
+        createdAt: linkedAt,
+        updatedAt: linkedAt,
+        schemaVersion: CURRENT_SCHEMA_VERSION,
+    };
+}
+async function upsertGroupContextParticipants(input) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "friends",
+        event: "friends.group_context_upsert_start",
+        message: "upserting shared-group participant context",
+        meta: {
+            participantCount: input.participants.length,
+            hasGroupExternalId: input.groupExternalId.trim().length > 0,
+        },
+    });
+    const groupExternalId = input.groupExternalId.trim();
+    if (!groupExternalId) {
+        return [];
+    }
+    const now = input.now ?? (() => new Date().toISOString());
+    const participants = dedupeParticipants(input.participants);
+    const results = [];
+    for (const participant of participants) {
+        const linkedAt = now();
+        const existing = await input.store.findByExternalId(participant.provider, participant.externalId);
+        if (!existing) {
+            const created = createAcquaintanceRecord(participant, groupExternalId, linkedAt);
+            await input.store.put(created.id, created);
+            results.push({
+                friendId: created.id,
+                name: created.name,
+                trustLevel: "acquaintance",
+                created: true,
+                updated: false,
+                addedGroupExternalId: true,
+            });
+            continue;
+        }
+        const hasGroupExternalId = existing.externalIds.some((externalId) => externalId.externalId === groupExternalId);
+        const promoteToAcquaintance = shouldPromoteToAcquaintance(existing);
+        const trustLevel = promoteToAcquaintance
+            ? "acquaintance"
+            : existing.trustLevel;
+        const role = promoteToAcquaintance
+            ? "acquaintance"
+            : existing.role;
+        const updatedExternalIds = hasGroupExternalId
+            ? existing.externalIds
+            : [...existing.externalIds, createGroupExternalId(participant.provider, groupExternalId, linkedAt)];
+        const updated = promoteToAcquaintance || !hasGroupExternalId;
+        const record = updated
+            ? {
+                ...existing,
+                role,
+                trustLevel,
+                externalIds: updatedExternalIds,
+                updatedAt: linkedAt,
+            }
+            : existing;
+        if (updated) {
+            await input.store.put(record.id, record);
+        }
+        results.push({
+            friendId: record.id,
+            name: record.name,
+            trustLevel,
+            created: false,
+            updated,
+            addedGroupExternalId: !hasGroupExternalId,
+        });
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "friends",
+        event: "friends.group_context_upsert_end",
+        message: "upserted shared-group participant context",
+        meta: {
+            participantCount: participants.length,
+            updatedCount: results.filter((result) => result.created || result.updated).length,
+        },
+    });
+    return results;
+}

package/dist/mind/friends/resolver.js

@@ -31,6 +31,43 @@ class FriendResolver {
         }
         if (existing)
             return existing;
+        // Migration: local provider previously used "${username}@${hostname}" format.
+        // If no exact match, try finding a friend with old-format external ID.
+        /* v8 ignore start -- migration path: only fires when legacy hostname-format friend exists @preserve */
+        if (this.params.provider === "local" && !this.params.externalId.includes("@")) {
+            try {
+                const all = typeof this.store.listAll === "function" ? await this.store.listAll() : [];
+                /* v8 ignore start -- migration path: only fires when legacy hostname-format friend exists @preserve */
+                const migrationMatch = all.find((f) => f.externalIds.some((eid) => eid.provider === "local" && eid.externalId.startsWith(this.params.externalId + "@")));
+                if (migrationMatch) {
+                    const now = new Date().toISOString();
+                    migrationMatch.externalIds.push({
+                        provider: this.params.provider,
+                        externalId: this.params.externalId,
+                        linkedAt: now,
+                    });
+                    migrationMatch.updatedAt = now;
+                    try {
+                        await this.store.put(migrationMatch.id, migrationMatch);
+                    }
+                    catch {
+                        // best-effort persist
+                    }
+                    (0, runtime_1.emitNervesEvent)({
+                        component: "friends",
+                        event: "friends.local_id_migrated",
+                        message: `migrated local friend identity from hostname format to username-only`,
+                        meta: { friendId: migrationMatch.id, newExternalId: this.params.externalId },
+                    });
+                    return migrationMatch;
+                }
+                /* v8 ignore stop */
+            }
+            catch {
+                // fall through to create new
+            }
+        }
+        /* v8 ignore stop */
         // First encounter -- create new FriendRecord
         const now = new Date().toISOString();
         const externalId = {

package/dist/mind/friends/store-file.js

@@ -55,10 +55,29 @@ class FileFriendStore {
         });
     }
     async get(id) {
+        // Direct UUID lookup
         const record = await this.readJson(path.join(this.friendsPath, `${id}.json`));
-        if (!record)
-            return null;
-        return this.normalize(record);
+        if (record)
+            return this.normalize(record);
+        // Fallback: if id is a name (not UUID), scan for matching friend
+        /* v8 ignore start -- name fallback: exercised by live proactive sends @preserve */
+        try {
+            const entries = await fsPromises.readdir(this.friendsPath);
+            for (const entry of entries) {
+                if (!entry.endsWith(".json"))
+                    continue;
+                const raw = await this.readJson(path.join(this.friendsPath, entry));
+                if (!raw)
+                    continue;
+                const normalized = this.normalize(raw);
+                if (normalized.name?.toLowerCase() === id.toLowerCase()) {
+                    return normalized;
+                }
+            }
+        }
+        catch { /* directory unreadable — return null */ }
+        /* v8 ignore stop */
+        return null;
     }
     async put(id, record) {
         await this.writeJson(path.join(this.friendsPath, `${id}.json`), this.normalize(record));
@@ -100,6 +119,25 @@ class FileFriendStore {
         }
         return entries.some((entry) => entry.endsWith(".json"));
     }
+    async listAll() {
+        let entries;
+        try {
+            entries = await fsPromises.readdir(this.friendsPath);
+        }
+        catch {
+            return [];
+        }
+        const records = [];
+        for (const entry of entries) {
+            if (!entry.endsWith(".json"))
+                continue;
+            const raw = await this.readJson(path.join(this.friendsPath, entry));
+            if (!raw)
+                continue;
+            records.push(this.normalize(raw));
+        }
+        return records;
+    }
     normalize(raw) {
         const trustLevel = raw.trustLevel;
         const normalizedTrustLevel = trustLevel === "family" ||
@@ -108,6 +146,8 @@ class FileFriendStore {
             trustLevel === "stranger"
             ? trustLevel
             : DEFAULT_TRUST_LEVEL;
+        const kind = raw.kind === "human" || raw.kind === "agent" ? raw.kind : "human";
+        const agentMeta = kind === "agent" ? this.normalizeAgentMeta(raw.agentMeta) : undefined;
         return {
             id: raw.id,
             name: raw.name,
@@ -134,6 +174,21 @@ class FileFriendStore {
             createdAt: typeof raw.createdAt === "string" ? raw.createdAt : new Date().toISOString(),
             updatedAt: typeof raw.updatedAt === "string" ? raw.updatedAt : new Date().toISOString(),
             schemaVersion: typeof raw.schemaVersion === "number" ? raw.schemaVersion : 1,
+            kind,
+            agentMeta,
+        };
+    }
+    normalizeAgentMeta(raw) {
+        if (!raw || typeof raw !== "object" || Array.isArray(raw))
+            return undefined;
+        const meta = raw;
+        if (typeof meta.bundleName !== "string")
+            return undefined;
+        return {
+            bundleName: meta.bundleName,
+            familiarity: typeof meta.familiarity === "number" ? meta.familiarity : 0,
+            sharedMissions: Array.isArray(meta.sharedMissions) ? meta.sharedMissions : [],
+            outcomes: Array.isArray(meta.outcomes) ? meta.outcomes : [],
         };
     }
     async readJson(filePath) {

package/dist/mind/friends/trust-explanation.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeTrustContext = describeTrustContext;
+const runtime_1 = require("../../nerves/runtime");
+function findRelatedGroupId(friend) {
+    return friend.externalIds.find((externalId) => externalId.externalId.startsWith("group:"))?.externalId;
+}
+function resolveLevel(friend) {
+    return friend.trustLevel ?? "stranger";
+}
+function describeTrustContext(input) {
+    const level = resolveLevel(input.friend);
+    const relatedGroupId = findRelatedGroupId(input.friend);
+    const explanation = level === "family" || level === "friend"
+        ? {
+            level,
+            basis: "direct",
+            summary: level === "family"
+                ? "direct family trust"
+                : "direct trusted relationship",
+            why: "this relationship is directly trusted rather than inferred through a shared group or cold first contact.",
+            permits: [
+                "local operations when appropriate",
+                "proactive follow-through",
+                "full collaborative problem solving",
+            ],
+            constraints: [],
+        }
+        : level === "acquaintance"
+            ? {
+                level,
+                basis: "shared_group",
+                summary: relatedGroupId
+                    ? "known through the shared project group"
+                    : "known through a shared group context",
+                why: relatedGroupId
+                    ? `this trust comes from the shared group context ${relatedGroupId}, not from direct endorsement.`
+                    : "this trust comes from shared group context rather than direct endorsement.",
+                permits: [
+                    "group-safe coordination",
+                    "normal conversation inside the shared context",
+                ],
+                constraints: [
+                    "guarded local actions",
+                    "do not assume broad private authority",
+                ],
+                relatedGroupId,
+            }
+            : {
+                level,
+                basis: "unknown",
+                summary: "truly unknown first-contact context",
+                why: "this person is not known through direct trust or a shared group context.",
+                permits: [
+                    "safe first-contact orientation only",
+                ],
+                constraints: [
+                    "first contact does not reach the full model on open channels",
+                    "no local or privileged actions",
+                ],
+            };
+    (0, runtime_1.emitNervesEvent)({
+        component: "friends",
+        event: "friends.trust_explained",
+        message: "built explicit trust explanation",
+        meta: {
+            channel: input.channel,
+            level: explanation.level,
+            basis: explanation.basis,
+            hasRelatedGroup: Boolean(explanation.relatedGroupId),
+        },
+    });
+    return explanation;
+}

package/dist/mind/friends/types.js

@@ -2,8 +2,10 @@
 // Context kernel type definitions.
 // FriendRecord (merged identity + memory), channel capabilities, and resolved context.
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRUSTED_LEVELS = void 0;
 exports.isIdentityProvider = isIdentityProvider;
 exports.isIntegration = isIntegration;
+exports.isTrustedLevel = isTrustedLevel;
 const runtime_1 = require("../../nerves/runtime");
 const IDENTITY_PROVIDERS = new Set(["aad", "local", "teams-conversation", "imessage-handle"]);
 function isIdentityProvider(value) {
@@ -19,3 +21,9 @@ const INTEGRATIONS = new Set(["ado", "github", "graph"]);
 function isIntegration(value) {
     return typeof value === "string" && INTEGRATIONS.has(value);
 }
+/** Trust levels that grant full tool access and proactive send capability. */
+exports.TRUSTED_LEVELS = new Set(["family", "friend"]);
+/** Whether a trust level grants full access (family or friend). Defaults to "friend" for legacy records. */
+function isTrustedLevel(trustLevel) {
+    return exports.TRUSTED_LEVELS.has(trustLevel ?? "friend");
+}