@ouro.bot/cli 0.1.0-alpha.69 → 0.1.0-alpha.691

package/dist/heart/safe-workspace.js

@@ -1,228 +0,0 @@
-"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.resetSafeWorkspaceSelection = resetSafeWorkspaceSelection;
-exports.getActiveSafeWorkspaceSelection = getActiveSafeWorkspaceSelection;
-exports.ensureSafeRepoWorkspace = ensureSafeRepoWorkspace;
-exports.resolveSafeRepoPath = resolveSafeRepoPath;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const child_process_1 = require("child_process");
-const identity_1 = require("./identity");
-const runtime_1 = require("../nerves/runtime");
-let activeSelection = null;
-let cleanupHookRegistered = false;
-function defaultNow() {
-    return Date.now();
-}
-function resolveAgentName(explicit) {
-    if (explicit && explicit.trim().length > 0)
-        return explicit.trim();
-    try {
-        return (0, identity_1.getAgentName)();
-    }
-    catch {
-        return "slugger";
-    }
-}
-function runGit(cwd, args, spawnSync) {
-    return spawnSync("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
-}
-function readStdout(result) {
-    return (result.stdout ?? Buffer.from("")).toString("utf-8").trim();
-}
-function readStderr(result) {
-    return (result.stderr ?? Buffer.from("")).toString("utf-8").trim();
-}
-function assertGitOk(result, action) {
-    if (result.error) {
-        throw result.error;
-    }
-    if (result.status !== 0) {
-        const detail = readStderr(result) || readStdout(result) || `exit ${result.status ?? "unknown"}`;
-        throw new Error(`${action} failed: ${detail}`);
-    }
-    return readStdout(result);
-}
-function isGitClone(repoRoot, spawnSync) {
-    const result = runGit(repoRoot, ["rev-parse", "--is-inside-work-tree"], spawnSync);
-    return result.status === 0 && readStdout(result) === "true";
-}
-function readCurrentBranch(repoRoot, spawnSync) {
-    return assertGitOk(runGit(repoRoot, ["rev-parse", "--abbrev-ref", "HEAD"], spawnSync), "git branch read");
-}
-function ensureFetchedOrigin(repoRoot, spawnSync) {
-    assertGitOk(runGit(repoRoot, ["fetch", "origin"], spawnSync), "git fetch origin");
-}
-function ensureMainFastForward(repoRoot, spawnSync) {
-    assertGitOk(runGit(repoRoot, ["pull", "--ff-only", "origin", "main"], spawnSync), "git pull --ff-only origin main");
-}
-function createDedicatedWorktree(repoRoot, workspaceRoot, branchSuffix, existsSync, mkdirSync, rmSync, spawnSync) {
-    mkdirSync(path.dirname(workspaceRoot), { recursive: true });
-    const branchName = `slugger/${branchSuffix}`;
-    if (existsSync(workspaceRoot)) {
-        rmSync(workspaceRoot, { recursive: true, force: true });
-    }
-    assertGitOk(runGit(repoRoot, ["worktree", "add", "-B", branchName, workspaceRoot, "origin/main"], spawnSync), "git worktree add");
-    return { workspaceRoot, created: true };
-}
-function createScratchClone(workspaceRoot, cloneUrl, existsSync, mkdirSync, rmSync, spawnSync) {
-    mkdirSync(path.dirname(workspaceRoot), { recursive: true });
-    if (existsSync(workspaceRoot)) {
-        rmSync(workspaceRoot, { recursive: true, force: true });
-    }
-    const result = spawnSync("git", ["clone", "--depth", "1", "--branch", "main", cloneUrl, workspaceRoot], {
-        stdio: ["ignore", "pipe", "pipe"],
-    });
-    assertGitOk(result, "git clone");
-    return { workspaceRoot, created: true };
-}
-function registerCleanupHook(options) {
-    if (cleanupHookRegistered)
-        return;
-    cleanupHookRegistered = true;
-    process.on("exit", () => {
-        if (!activeSelection?.cleanupAfterMerge)
-            return;
-        try {
-            options.rmSync(activeSelection.workspaceRoot, { recursive: true, force: true });
-        }
-        catch {
-            // best effort
-        }
-    });
-}
-function resetSafeWorkspaceSelection(options = {}) {
-    activeSelection = null;
-    if (!options.keepCleanupHookRegistered) {
-        cleanupHookRegistered = false;
-    }
-}
-function getActiveSafeWorkspaceSelection() {
-    return activeSelection;
-}
-function ensureSafeRepoWorkspace(options = {}) {
-    if (activeSelection) {
-        return activeSelection;
-    }
-    const repoRoot = options.repoRoot ?? (0, identity_1.getRepoRoot)();
-    const agentName = resolveAgentName(options.agentName);
-    const canonicalRepoUrl = options.canonicalRepoUrl ?? identity_1.HARNESS_CANONICAL_REPO_URL;
-    const workspaceBase = options.workspaceRoot ?? (0, identity_1.getAgentRepoWorkspacesRoot)(agentName);
-    const spawnSync = options.spawnSync ?? child_process_1.spawnSync;
-    const existsSync = options.existsSync ?? fs.existsSync;
-    const mkdirSync = options.mkdirSync ?? fs.mkdirSync;
-    const rmSync = options.rmSync ?? fs.rmSync;
-    const now = options.now ?? defaultNow;
-    const stamp = String(now());
-    registerCleanupHook({ rmSync });
-    let selection;
-    if (isGitClone(repoRoot, spawnSync)) {
-        const branch = readCurrentBranch(repoRoot, spawnSync);
-        ensureFetchedOrigin(repoRoot, spawnSync);
-        if (branch === "main") {
-            ensureMainFastForward(repoRoot, spawnSync);
-            const worktreeRoot = path.join(workspaceBase, `ouroboros-main-${stamp}`);
-            const created = createDedicatedWorktree(repoRoot, worktreeRoot, `safe-workspace-${stamp}`, existsSync, mkdirSync, rmSync, spawnSync);
-            selection = {
-                runtimeKind: "clone-main",
-                repoRoot,
-                workspaceRoot: created.workspaceRoot,
-                sourceBranch: branch,
-                sourceCloneUrl: canonicalRepoUrl,
-                cleanupAfterMerge: false,
-                created: created.created,
-                note: `running from clone on main; fast-forwarded and created dedicated worktree ${created.workspaceRoot}`,
-            };
-        }
-        else {
-            const worktreeRoot = path.join(workspaceBase, `ouroboros-origin-main-${stamp}`);
-            const created = createDedicatedWorktree(repoRoot, worktreeRoot, `safe-workspace-${stamp}`, existsSync, mkdirSync, rmSync, spawnSync);
-            selection = {
-                runtimeKind: "clone-non-main",
-                repoRoot,
-                workspaceRoot: created.workspaceRoot,
-                sourceBranch: branch,
-                sourceCloneUrl: canonicalRepoUrl,
-                cleanupAfterMerge: false,
-                created: created.created,
-                note: `running from branch ${branch}; defaulted new work from origin/main in dedicated worktree ${created.workspaceRoot}`,
-            };
-        }
-    }
-    else {
-        const scratchRoot = path.join(workspaceBase, `ouroboros-scratch-${stamp}`);
-        const created = createScratchClone(scratchRoot, canonicalRepoUrl, existsSync, mkdirSync, rmSync, spawnSync);
-        selection = {
-            runtimeKind: "installed-runtime",
-            repoRoot,
-            workspaceRoot: created.workspaceRoot,
-            sourceBranch: null,
-            sourceCloneUrl: canonicalRepoUrl,
-            cleanupAfterMerge: true,
-            created: created.created,
-            note: `running from installed runtime/wrapper; created scratch clone ${created.workspaceRoot} from ${canonicalRepoUrl}`,
-        };
-    }
-    activeSelection = selection;
-    (0, runtime_1.emitNervesEvent)({
-        component: "workspace",
-        event: "workspace.safe_repo_acquired",
-        message: "acquired safe repo workspace before local edits",
-        meta: {
-            runtimeKind: selection.runtimeKind,
-            repoRoot: selection.repoRoot,
-            workspaceRoot: selection.workspaceRoot,
-            sourceBranch: selection.sourceBranch,
-            sourceCloneUrl: selection.sourceCloneUrl,
-            cleanupAfterMerge: selection.cleanupAfterMerge,
-        },
-    });
-    return selection;
-}
-function resolveSafeRepoPath(options) {
-    const requestedPath = path.resolve(options.requestedPath);
-    const repoRoot = path.resolve(options.repoRoot ?? (0, identity_1.getRepoRoot)());
-    if (activeSelection && requestedPath.startsWith(activeSelection.workspaceRoot + path.sep)) {
-        return { selection: activeSelection, resolvedPath: requestedPath };
-    }
-    if (requestedPath !== repoRoot && !requestedPath.startsWith(repoRoot + path.sep)) {
-        return { selection: activeSelection, resolvedPath: requestedPath };
-    }
-    const selection = ensureSafeRepoWorkspace(options);
-    const relativePath = requestedPath === repoRoot ? "" : path.relative(repoRoot, requestedPath);
-    const resolvedPath = relativePath ? path.join(selection.workspaceRoot, relativePath) : selection.workspaceRoot;
-    return { selection, resolvedPath };
-}

package/dist/heart/session-recall.js

@@ -1,116 +0,0 @@
-"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.recallSession = recallSession;
-const fs = __importStar(require("fs"));
-const runtime_1 = require("../nerves/runtime");
-function normalizeContent(content) {
-    if (typeof content === "string")
-        return content;
-    if (!Array.isArray(content))
-        return "";
-    return content
-        .map((part) => (part && typeof part === "object" && "type" in part && part.type === "text" && "text" in part
-        ? String(part.text ?? "")
-        : ""))
-        .filter((text) => text.length > 0)
-        .join("");
-}
-function buildSummaryInstruction(friendId, channel, trustLevel) {
-    if (friendId === "self" && channel === "inner") {
-        return "summarize this session transcript fully and transparently. this is my own inner dialog — include all details, decisions, and reasoning.";
-    }
-    return `summarize this session transcript. the person asking has trust level: ${trustLevel}. family=full transparency, friend=share work and general topics but protect other people's identities, acquaintance=very guarded minimal disclosure.`;
-}
-function clip(text, limit = 160) {
-    const compact = text.replace(/\s+/g, " ").trim();
-    return compact.length > limit ? compact.slice(0, limit - 1) + "…" : compact;
-}
-function buildSnapshot(summary, tailMessages) {
-    const lines = [`recent focus: ${clip(summary, 240)}`];
-    const latestUser = [...tailMessages].reverse().find((message) => message.role === "user")?.content;
-    const latestAssistant = [...tailMessages].reverse().find((message) => message.role === "assistant")?.content;
-    if (latestUser) {
-        lines.push(`latest user: ${clip(latestUser)}`);
-    }
-    if (latestAssistant) {
-        lines.push(`latest assistant: ${clip(latestAssistant)}`);
-    }
-    return lines.join("\n");
-}
-async function recallSession(options) {
-    (0, runtime_1.emitNervesEvent)({
-        component: "daemon",
-        event: "daemon.session_recall",
-        message: "recalling session transcript tail",
-        meta: {
-            friendId: options.friendId,
-            channel: options.channel,
-            key: options.key,
-            messageCount: options.messageCount,
-        },
-    });
-    let raw;
-    try {
-        raw = fs.readFileSync(options.sessionPath, "utf-8");
-    }
-    catch {
-        return { kind: "missing" };
-    }
-    const parsed = JSON.parse(raw);
-    const tailMessages = (parsed.messages ?? [])
-        .map((message) => ({
-        role: typeof message.role === "string" ? message.role : "",
-        content: normalizeContent(message.content),
-    }))
-        .filter((message) => message.role !== "system" && message.content.length > 0)
-        .slice(-options.messageCount);
-    if (tailMessages.length === 0) {
-        return { kind: "empty" };
-    }
-    const transcript = tailMessages
-        .map((message) => `[${message.role}] ${message.content}`)
-        .join("\n");
-    const summary = options.summarize
-        ? await options.summarize(transcript, buildSummaryInstruction(options.friendId, options.channel, options.trustLevel ?? "family"))
-        : transcript;
-    return {
-        kind: "ok",
-        transcript,
-        summary,
-        snapshot: buildSnapshot(summary, tailMessages),
-        tailMessages,
-    };
-}

package/dist/mind/friends/channel.js

@@ -1,84 +0,0 @@
-"use strict";
-// 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.getChannelCapabilities = getChannelCapabilities;
-exports.isRemoteChannel = isRemoteChannel;
-exports.getAlwaysOnSenseNames = getAlwaysOnSenseNames;
-const runtime_1 = require("../../nerves/runtime");
-const CHANNEL_CAPABILITIES = {
-    cli: {
-        channel: "cli",
-        senseType: "local",
-        availableIntegrations: [],
-        supportsMarkdown: false,
-        supportsStreaming: true,
-        supportsRichCards: false,
-        maxMessageLength: Infinity,
-    },
-    teams: {
-        channel: "teams",
-        senseType: "closed",
-        availableIntegrations: ["ado", "graph", "github"],
-        supportsMarkdown: true,
-        supportsStreaming: true,
-        supportsRichCards: true,
-        maxMessageLength: Infinity,
-    },
-    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,
-    },
-};
-const DEFAULT_CAPABILITIES = {
-    channel: "cli",
-    senseType: "local",
-    availableIntegrations: [],
-    supportsMarkdown: false,
-    supportsStreaming: false,
-    supportsRichCards: false,
-    maxMessageLength: Infinity,
-};
-function getChannelCapabilities(channel) {
-    (0, runtime_1.emitNervesEvent)({
-        component: "channels",
-        event: "channel.capabilities_lookup",
-        message: "channel capabilities lookup",
-        meta: { 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

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

@@ -1,84 +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 memory resolution.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FriendResolver = void 0;
-const crypto_1 = require("crypto");
-const channel_1 = require("./channel");
-const runtime_1 = require("../../nerves/runtime");
-const CURRENT_SCHEMA_VERSION = 1;
-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;
-        // 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 friend = {
-            id: (0, crypto_1.randomUUID)(),
-            name: this.params.displayName,
-            role: isFirstImprint ? "primary" : "stranger",
-            trustLevel: isFirstImprint ? "family" : "stranger",
-            connections: [],
-            externalIds: [externalId],
-            tenantMemberships,
-            toolPreferences: {},
-            notes: this.params.displayName !== "Unknown" ? { name: { value: this.params.displayName, savedAt: now } } : {},
-            totalTokens: 0,
-            createdAt: now,
-            updatedAt: now,
-            schemaVersion: CURRENT_SCHEMA_VERSION,
-        };
-        // 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;