@ouro.bot/cli 0.1.0-alpha.669 → 0.1.0-alpha.670

package/dist/mind/friends/resolver.js

@@ -1,187 +0,0 @@
-"use strict";
-// FriendResolver -- resolves external identity into a FriendRecord + channel capabilities.
-// Created per-request (per-incoming-message), per-friend.
-// Replaces the old ContextResolver: no authority checker, no separate note resolution.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FriendResolver = void 0;
-exports._setMachineOwnerUsernameForTest = _setMachineOwnerUsernameForTest;
-exports.machineOwnerUsername = machineOwnerUsername;
-exports.isLocalMachineOwnerIdentity = isLocalMachineOwnerIdentity;
-const crypto_1 = require("crypto");
-const os_1 = require("os");
-const channel_1 = require("./channel");
-const runtime_1 = require("../../nerves/runtime");
-const CURRENT_SCHEMA_VERSION = 1;
-// Test seam: when set (including to null), overrides OS detection of the
-// machine-owner username so resolver tests are deterministic.
-let machineOwnerOverride;
-function _setMachineOwnerUsernameForTest(value) {
-    machineOwnerOverride = value;
-}
-/**
- * The OS username that owns this daemon process, or null if undetectable. The
- * person running the daemon owns this agent + its bundle, so the local friend
- * that names them is the machine owner (family), not a stranger.
- */
-function machineOwnerUsername() {
-    if (machineOwnerOverride !== undefined)
-        return machineOwnerOverride;
-    try {
-        return (0, os_1.userInfo)().username;
-    }
-    catch {
-        /* v8 ignore next -- defensive: userInfo() only throws when the running user has no passwd entry @preserve */
-        return null;
-    }
-}
-/**
- * True when (provider, externalId) names the local machine owner — the OS user
- * running the daemon. Matches the bare username or a `user@host` external id.
- */
-function isLocalMachineOwnerIdentity(provider, externalId, ownerUsername) {
-    if (provider !== "local" || !ownerUsername)
-        return false;
-    return externalId === ownerUsername || externalId.startsWith(`${ownerUsername}@`);
-}
-class FriendResolver {
-    store;
-    params;
-    constructor(store, params) {
-        this.store = store;
-        this.params = params;
-    }
-    async resolve() {
-        const friend = await this.resolveOrCreate();
-        const channel = (0, channel_1.getChannelCapabilities)(this.params.channel);
-        return { friend, channel };
-    }
-    async resolveOrCreate() {
-        // Try to find existing friend by external ID
-        let existing = null;
-        try {
-            existing = await this.store.findByExternalId(this.params.provider, this.params.externalId, this.params.tenantId);
-        }
-        catch {
-            // Store search failure -- fall through to create new (D16)
-        }
-        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 = {
-            provider: this.params.provider,
-            externalId: this.params.externalId,
-            linkedAt: now,
-            ...(this.params.tenantId !== undefined ? { tenantId: this.params.tenantId } : {}),
-        };
-        const tenantMemberships = this.params.tenantId ? [this.params.tenantId] : [];
-        let hasAnyFriends = false;
-        try {
-            if (typeof this.store.hasAnyFriends === "function") {
-                hasAnyFriends = await this.store.hasAnyFriends();
-            }
-        }
-        catch {
-            hasAnyFriends = false;
-        }
-        const isFirstImprint = !hasAnyFriends;
-        const isA2AAgent = this.params.provider === "a2a-agent";
-        // The local friend that names the OS user running the daemon is the machine
-        // owner (family) — they own the agent + its bundle. Usually this friend already
-        // exists as a family/primary hatch imprint; this covers the un-imprinted boss
-        // path (e.g. a Workbench boss check-in on a bundle that skipped imprint).
-        const isLocalMachineOwner = isLocalMachineOwnerIdentity(this.params.provider, this.params.externalId, machineOwnerUsername());
-        // BlueBubbles group chats route through here as `imessage-handle` with an
-        // externalId of the form `group:any;+;<chatHash>`. When the harness auto-
-        // creates the group friend at stranger trust, we mark the record so that
-        // the trust gate can surface the relationship for explicit acknowledgment
-        // later instead of letting messages accumulate silently.
-        const isImessageGroup = this.params.provider === "imessage-handle" &&
-            typeof this.params.externalId === "string" &&
-            this.params.externalId.startsWith("group:");
-        const notes = {};
-        if (this.params.displayName !== "Unknown") {
-            notes.name = { value: this.params.displayName, savedAt: now };
-        }
-        if (isImessageGroup && !isFirstImprint) {
-            notes.autoCreatedGroup = { value: "true", savedAt: now };
-        }
-        const friend = {
-            id: (0, crypto_1.randomUUID)(),
-            name: this.params.displayName,
-            role: isA2AAgent ? "agent-peer" : isFirstImprint ? "primary" : isLocalMachineOwner ? "family" : "stranger",
-            trustLevel: isA2AAgent ? "stranger" : (isFirstImprint || isLocalMachineOwner) ? "family" : "stranger",
-            connections: [],
-            externalIds: [externalId],
-            tenantMemberships,
-            toolPreferences: {},
-            notes,
-            totalTokens: 0,
-            createdAt: now,
-            updatedAt: now,
-            schemaVersion: CURRENT_SCHEMA_VERSION,
-            kind: isA2AAgent ? "agent" : "human",
-            ...(isA2AAgent ? {
-                agentMeta: {
-                    bundleName: this.params.displayName,
-                    familiarity: 0,
-                    sharedMissions: [],
-                    outcomes: [],
-                    a2a: { agentId: this.params.externalId },
-                },
-            } : {}),
-        };
-        // Persist -- log and continue on failure (D16)
-        try {
-            await this.store.put(friend.id, friend);
-        }
-        catch (err) {
-            (0, runtime_1.emitNervesEvent)({
-                level: "error",
-                event: "friends.persist_error",
-                component: "friends",
-                message: "failed to persist friend record",
-                meta: { reason: err instanceof Error ? err.message : String(err) },
-            });
-        }
-        return friend;
-    }
-}
-exports.FriendResolver = FriendResolver;

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

@@ -1,247 +0,0 @@
-"use strict";
-// FileFriendStore -- filesystem adapter for FriendStore.
-// Stores each friend as one unified JSON file in bundle `friends/`.
-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.FileFriendStore = void 0;
-const fs = __importStar(require("fs"));
-const fsPromises = __importStar(require("fs/promises"));
-const path = __importStar(require("path"));
-const session_events_1 = require("../../heart/session-events");
-const runtime_1 = require("../../nerves/runtime");
-const DEFAULT_ROLE = "friend";
-const DEFAULT_TRUST_LEVEL = "friend";
-class FileFriendStore {
-    friendsPath;
-    constructor(friendsPath) {
-        this.friendsPath = friendsPath;
-        fs.mkdirSync(friendsPath, { recursive: true });
-        (0, runtime_1.emitNervesEvent)({
-            component: "friends",
-            event: "friends.store_init",
-            message: "file friend store initialized",
-            meta: {},
-        });
-    }
-    async get(id) {
-        // Direct UUID lookup
-        const record = await this.readJson(path.join(this.friendsPath, `${id}.json`));
-        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));
-    }
-    async delete(id) {
-        await this.removeFile(path.join(this.friendsPath, `${id}.json`));
-    }
-    async findByExternalId(provider, externalId, tenantId) {
-        let entries;
-        try {
-            entries = await fsPromises.readdir(this.friendsPath);
-        }
-        catch {
-            return null;
-        }
-        for (const entry of entries) {
-            if (!entry.endsWith(".json"))
-                continue;
-            const raw = await this.readJson(path.join(this.friendsPath, entry));
-            if (!raw)
-                continue;
-            const record = this.normalize(raw);
-            const match = record.externalIds.some((ext) => ext.provider === provider &&
-                ext.externalId === externalId &&
-                (tenantId === undefined || ext.tenantId === tenantId));
-            if (match) {
-                return record;
-            }
-        }
-        return null;
-    }
-    async hasAnyFriends() {
-        let entries;
-        try {
-            entries = await fsPromises.readdir(this.friendsPath);
-        }
-        catch {
-            return false;
-        }
-        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" ||
-            trustLevel === "friend" ||
-            trustLevel === "acquaintance" ||
-            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,
-            role: typeof raw.role === "string" && raw.role.trim() ? raw.role : DEFAULT_ROLE,
-            trustLevel: normalizedTrustLevel,
-            connections: Array.isArray(raw.connections)
-                ? raw.connections
-                    .filter((connection) => (typeof connection === "object" &&
-                    connection !== null &&
-                    typeof connection.name === "string" &&
-                    typeof connection.relationship === "string"))
-                    .map((connection) => ({
-                    name: connection.name,
-                    relationship: connection.relationship,
-                }))
-                : [],
-            externalIds: Array.isArray(raw.externalIds) ? raw.externalIds : [],
-            tenantMemberships: Array.isArray(raw.tenantMemberships) ? raw.tenantMemberships : [],
-            toolPreferences: raw.toolPreferences && typeof raw.toolPreferences === "object"
-                ? raw.toolPreferences
-                : {},
-            notes: raw.notes && typeof raw.notes === "object" ? raw.notes : {},
-            totalTokens: typeof raw.totalTokens === "number" ? raw.totalTokens : 0,
-            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 : [],
-            ...(this.normalizeA2AMeta(meta.a2a) ? { a2a: this.normalizeA2AMeta(meta.a2a) } : {}),
-        };
-    }
-    normalizeA2AMeta(raw) {
-        if (!raw || typeof raw !== "object" || Array.isArray(raw))
-            return undefined;
-        const meta = raw;
-        const a2a = {
-            ...(typeof meta.cardUrl === "string" ? { cardUrl: meta.cardUrl } : {}),
-            ...(typeof meta.endpointUrl === "string" ? { endpointUrl: meta.endpointUrl } : {}),
-            ...(typeof meta.agentId === "string" ? { agentId: meta.agentId } : {}),
-            ...(typeof meta.protocolVersion === "string" ? { protocolVersion: meta.protocolVersion } : {}),
-        };
-        return Object.keys(a2a).length > 0 ? a2a : undefined;
-    }
-    async readJson(filePath) {
-        try {
-            const raw = await fsPromises.readFile(filePath, "utf-8");
-            try {
-                const parsed = JSON.parse(raw);
-                if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-                    return null;
-                }
-                return parsed;
-            }
-            catch {
-                return null;
-            }
-        }
-        catch {
-            return null;
-        }
-    }
-    async writeJson(filePath, data) {
-        const notes = Object.fromEntries(Object.entries(data.notes).map(([key, note]) => [
-            key,
-            {
-                ...note,
-                value: (0, session_events_1.capStructuredRecordString)(note.value),
-            },
-        ]));
-        await fsPromises.writeFile(filePath, JSON.stringify({ ...data, notes }, null, 2), "utf-8");
-    }
-    async removeFile(filePath) {
-        try {
-            await fsPromises.unlink(filePath);
-        }
-        catch (err) {
-            if (err?.code === "ENOENT")
-                return;
-            throw err;
-        }
-    }
-}
-exports.FileFriendStore = FileFriendStore;

package/dist/mind/friends/store.js

@@ -1,4 +0,0 @@
-"use strict";
-// Friend store abstraction.
-// All friend persistence goes through FriendStore -- no friend module imports `fs` directly.
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/mind/friends/tokens.js

@@ -1,26 +0,0 @@
-"use strict";
-// Token accumulation helper.
-// Tracks cumulative token usage per friend across turns.
-// Called from both CLI and Teams adapters after each agent turn.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.accumulateFriendTokens = accumulateFriendTokens;
-const runtime_1 = require("../../nerves/runtime");
-async function accumulateFriendTokens(store, friendId, usage) {
-    if (!usage?.output_tokens)
-        return;
-    const record = await store.get(friendId);
-    if (!record)
-        return;
-    // Only count output tokens (what the model generated for this friend).
-    // Input tokens are mostly system prompt re-sent every turn -- counting them
-    // would inflate the total and make the onboarding threshold meaningless.
-    record.totalTokens = (record.totalTokens ?? 0) + usage.output_tokens;
-    record.updatedAt = new Date().toISOString();
-    await store.put(record.id, record);
-    (0, runtime_1.emitNervesEvent)({
-        component: "friends",
-        event: "friends.tokens_accumulated",
-        message: "tokens accumulated for friend",
-        meta: { friendId, outputTokens: usage.output_tokens },
-    });
-}

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

@@ -1,74 +0,0 @@
-"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

@@ -1,29 +0,0 @@
-"use strict";
-// Context kernel type definitions.
-// FriendRecord (merged identity + notes), 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", "email-address", "a2a-agent"]);
-function isIdentityProvider(value) {
-    (0, runtime_1.emitNervesEvent)({
-        component: "friends",
-        event: "friends.identity_provider_check",
-        message: "identity provider validation",
-        meta: {},
-    });
-    return typeof value === "string" && IDENTITY_PROVIDERS.has(value);
-}
-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");
-}