@intent-systems/nexus 2026.1.5-4 → 2026.1.5-8

package/dist/commands/init.js

@@ -3,12 +3,18 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { promisify } from "node:util";
 import { ensureAgentWorkspace } from "../agents/workspace.js";
-import { CONFIG_PATH_NEXUS, writeConfigFile } from "../config/config.js";
-import { resolveStateDir } from "../config/paths.js";
+import { CONFIG_PATH_NEXUS, readConfigFileSnapshot, writeConfigFile, } from "../config/config.js";
+import { resolveGatewayPort, resolveStateDir } from "../config/paths.js";
+import { GATEWAY_LAUNCH_AGENT_LABEL } from "../daemon/constants.js";
+import { resolveGatewayProgramArguments } from "../daemon/program-args.js";
+import { resolveGatewayService } from "../daemon/service.js";
 import { defaultRuntime } from "../runtime.js";
-import { NEXUS_ROOT } from "../utils.js";
-import { copyBundledSkills, generateSkillManifest, writeSkillManifest } from "./skills-manifest.js";
+import { NEXUS_ROOT, SKILLS_STATE_DIR, WORKSPACE_SKILLS_DIR, resolveUserPath, } from "../utils.js";
+import { scanCredentials } from "./credential.js";
+import { writeCursorHooks } from "./cursor-hooks.js";
 import { writeCursorRules } from "./cursor-rules.js";
+import { copyBundledSkills, generateSkillManifest, writeSkillManifest, } from "./skills-manifest.js";
+import { ensureSystemdUserLingerNonInteractive } from "./systemd-linger.js";
 const execFileAsync = promisify(execFile);
 /**
  * Checks if a directory is already a git repository.
@@ -77,37 +83,289 @@ build/
     await fs.writeFile(gitignorePath, gitignoreContent, "utf-8");
     runtime.log(`✓ Created .gitignore`);
 }
+function shouldCopyIdentity(env) {
+    return (env.NEXUS_INIT_COPY_IDENTITY === "1" ||
+        env.NEXUS_TEST_MODE === "1" ||
+        env.VITEST === "true" ||
+        env.NODE_ENV === "test");
+}
+function resolveIdentitySourceDir(env) {
+    const explicit = env.NEXUS_INIT_IDENTITY_SRC?.trim() || env.NEXUS_IDENTITY_DIR?.trim();
+    if (explicit)
+        return resolveUserPath(explicit);
+    if (!shouldCopyIdentity(env))
+        return null;
+    return resolveUserPath("~") + "/nexus";
+}
+function stripQuotes(value) {
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+        return value.slice(1, -1);
+    }
+    return value;
+}
+function readFrontmatterName(raw) {
+    const normalized = raw.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    if (!normalized.startsWith("---"))
+        return null;
+    const endIndex = normalized.indexOf("\n---", 3);
+    if (endIndex === -1)
+        return null;
+    const block = normalized.slice(4, endIndex);
+    for (const line of block.split("\n")) {
+        const match = line.match(/^name\s*:\s*(.+)$/i);
+        if (match?.[1])
+            return stripQuotes(match[1].trim());
+    }
+    return null;
+}
+function extractName(raw) {
+    const frontmatterName = readFrontmatterName(raw);
+    if (frontmatterName)
+        return frontmatterName;
+    const plainMatch = raw.match(/^[-*]?\s*Name\s*:\s*(.+)$/im);
+    if (plainMatch?.[1])
+        return plainMatch[1].trim();
+    const boldMatch = raw.match(/^\s*[-*]?\s*\*\*Name:\*\*\s*(.+)$/im);
+    if (boldMatch?.[1])
+        return boldMatch[1].trim();
+    return null;
+}
+function upsertFrontmatterName(raw, name) {
+    const normalized = raw.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    if (normalized.startsWith("---")) {
+        const endIndex = normalized.indexOf("\n---", 3);
+        if (endIndex !== -1) {
+            const block = normalized.slice(4, endIndex);
+            const hasName = block.split("\n").some((line) => /^name\s*:/i.test(line));
+            if (hasName)
+                return raw;
+            const updatedBlock = `name: ${name}\n${block}`;
+            return `---\n${updatedBlock}\n---${normalized.slice(endIndex + 4)}`;
+        }
+    }
+    return `---\nname: ${name}\n---\n\n${raw}`;
+}
+async function copyIdentityFile(params) {
+    try {
+        const raw = await fs.readFile(params.sourcePath, "utf-8");
+        let next = raw;
+        if (params.ensureNameLine) {
+            const name = extractName(raw);
+            if (name && !readFrontmatterName(raw)) {
+                next = upsertFrontmatterName(raw, name);
+            }
+        }
+        await fs.mkdir(path.dirname(params.destinationPath), { recursive: true });
+        await fs.writeFile(params.destinationPath, next, "utf-8");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function copyIdentityForInit(params) {
+    const sourceDir = resolveIdentitySourceDir(params.env);
+    if (!sourceDir)
+        return;
+    const resolvedSource = path.resolve(sourceDir);
+    const agentIdentityPath = params.workspace.identityPath;
+    const agentSoulPath = params.workspace.soulPath;
+    const agentMemoryPath = params.workspace.memoryPath;
+    const userIdentityPath = params.workspace.userPath;
+    if (!agentIdentityPath ||
+        !userIdentityPath ||
+        !agentSoulPath ||
+        !agentMemoryPath)
+        return;
+    const agentId = process.env.NEXUS_AGENT_ID?.trim() || "default";
+    const agentSources = [
+        path.join(resolvedSource, "IDENTITY.md"),
+        path.join(resolvedSource, "AGENT.md"),
+        path.join(resolvedSource, "agents", agentId, "IDENTITY.md"),
+        path.join(resolvedSource, "state", "agents", agentId, "IDENTITY.md"),
+        path.join(resolvedSource, "state", "identity", "AGENT.md"),
+        path.join(resolvedSource, "state", "identity", "IDENTITY.md"),
+    ];
+    const userSources = [
+        path.join(resolvedSource, "IDENTITY.md"),
+        path.join(resolvedSource, "PROFILE.md"),
+        path.join(resolvedSource, "USER.md"),
+        path.join(resolvedSource, "user", "IDENTITY.md"),
+        path.join(resolvedSource, "state", "user", "IDENTITY.md"),
+        path.join(resolvedSource, "state", "identity", "PROFILE.md"),
+        path.join(resolvedSource, "state", "identity", "USER.md"),
+    ];
+    const soulSources = [
+        path.join(resolvedSource, "SOUL.md"),
+        path.join(resolvedSource, "agents", agentId, "SOUL.md"),
+        path.join(resolvedSource, "state", "agents", agentId, "SOUL.md"),
+        path.join(resolvedSource, "state", "identity", "SOUL.md"),
+    ];
+    const memorySources = [
+        path.join(resolvedSource, "MEMORY.md"),
+        path.join(resolvedSource, "agents", agentId, "MEMORY.md"),
+        path.join(resolvedSource, "state", "agents", agentId, "MEMORY.md"),
+        path.join(resolvedSource, "state", "identity", "MEMORY.md"),
+    ];
+    const pickExisting = async (candidates) => {
+        for (const candidate of candidates) {
+            try {
+                await fs.access(candidate);
+                return candidate;
+            }
+            catch {
+                // continue
+            }
+        }
+        return null;
+    };
+    const agentSource = await pickExisting(agentSources);
+    const userSource = await pickExisting(userSources);
+    const wroteAgent = agentSource
+        ? await copyIdentityFile({
+            sourcePath: agentSource,
+            destinationPath: agentIdentityPath,
+            ensureNameLine: true,
+        })
+        : false;
+    const wroteUser = userSource
+        ? await copyIdentityFile({
+            sourcePath: userSource,
+            destinationPath: userIdentityPath,
+            ensureNameLine: true,
+        })
+        : false;
+    const soulSource = await pickExisting(soulSources);
+    const memorySource = await pickExisting(memorySources);
+    const wroteSoul = soulSource
+        ? await copyIdentityFile({
+            sourcePath: soulSource,
+            destinationPath: agentSoulPath,
+        })
+        : false;
+    const wroteMemory = memorySource
+        ? await copyIdentityFile({
+            sourcePath: memorySource,
+            destinationPath: agentMemoryPath,
+        })
+        : false;
+    if (wroteAgent || wroteUser || wroteSoul || wroteMemory) {
+        params.runtime.log(`✓ Copied identity files from ${resolvedSource} (bootstrap skipped)`);
+    }
+}
+function isGatewayCommandMatch(existing, expected) {
+    const existingArgs = existing.programArguments.map((arg) => arg.trim());
+    const expectedArgs = expected.programArguments.map((arg) => arg.trim());
+    if (existingArgs.length !== expectedArgs.length)
+        return false;
+    for (let i = 0; i < expectedArgs.length; i += 1) {
+        if (existingArgs[i] !== expectedArgs[i])
+            return false;
+    }
+    const existingDir = existing.workingDirectory?.trim() || "";
+    const expectedDir = expected.workingDirectory?.trim() || "";
+    return existingDir === expectedDir;
+}
+function hasGatewayEnvMismatch(existing, expected) {
+    const keysToCheck = Object.entries(expected).filter(([key]) => key !== "PATH");
+    if (!existing?.environment) {
+        return keysToCheck.some(([, value]) => Boolean(value?.trim()));
+    }
+    for (const [key, value] of keysToCheck) {
+        if (!value?.trim())
+            continue;
+        if (existing.environment[key] !== value) {
+            return true;
+        }
+    }
+    return false;
+}
+async function ensureGatewayDaemon(params) {
+    if (params.env.NEXUS_INIT_SKIP_DAEMON === "1")
+        return;
+    const runtime = params.runtime;
+    let nextConfig = params.configSnapshot.config ?? {};
+    const gateway = { ...nextConfig.gateway };
+    let updated = false;
+    if (!gateway.mode) {
+        gateway.mode = "local";
+        updated = true;
+    }
+    if (!gateway.bind) {
+        gateway.bind = "loopback";
+        updated = true;
+    }
+    const tailscaleMode = gateway.tailscale?.mode;
+    if (!tailscaleMode) {
+        gateway.tailscale = { ...gateway.tailscale, mode: "off" };
+        updated = true;
+    }
+    if (updated) {
+        nextConfig = { ...nextConfig, gateway };
+        await writeConfigFile(nextConfig);
+        runtime.log(`✓ Updated config file: ${CONFIG_PATH_NEXUS}`);
+    }
+    await ensureSystemdUserLingerNonInteractive({ runtime, env: params.env });
+    const service = resolveGatewayService();
+    const loaded = await service.isLoaded({ env: params.env });
+    const port = resolveGatewayPort(nextConfig, params.env);
+    const devMode = process.argv[1]?.includes("/src/") && process.argv[1]?.endsWith(".ts");
+    const { programArguments, workingDirectory } = await resolveGatewayProgramArguments({ port, dev: devMode });
+    const environment = {
+        PATH: params.env.PATH,
+        NEXUS_ROOT: params.env.NEXUS_ROOT,
+        NEXUS_STATE_DIR: params.env.NEXUS_STATE_DIR,
+        NEXUS_AGENT_ID: params.env.NEXUS_AGENT_ID,
+        NEXUS_PROFILE: params.env.NEXUS_PROFILE,
+        NEXUS_LAUNCHD_LABEL: process.platform === "darwin" ? GATEWAY_LAUNCH_AGENT_LABEL : undefined,
+    };
+    const existing = loaded ? await service.readCommand(params.env) : null;
+    const shouldReinstall = !existing ||
+        !isGatewayCommandMatch(existing, { programArguments, workingDirectory }) ||
+        hasGatewayEnvMismatch(existing, environment);
+    if (!loaded || shouldReinstall) {
+        await service.install({
+            env: params.env,
+            stdout: process.stdout,
+            programArguments,
+            workingDirectory,
+            environment,
+        });
+        runtime.log(`✓ Installed ${service.label} gateway daemon`);
+    }
+    else {
+        await service.restart({ stdout: process.stdout });
+        runtime.log(`✓ Restarted ${service.label} gateway daemon`);
+    }
+}
 /**
  * Creates the Nexus directory structure:
- * - ~/nexus/ (root with AGENTS.md and .cursor/rules)
+ * - ~/nexus/ (root with AGENTS.md, .cursor/rules, .cursor/hooks.json)
  * - ~/nexus/home/ (user workspace)
  * - ~/nexus/state/ (state directory)
  */
 export async function initCommand(opts, runtime = defaultRuntime) {
-    const workspaceDir = opts?.workspace?.trim() || path.join(process.env.HOME || "~", "nexus", "home");
+    const workspaceDir = opts?.workspace?.trim() ||
+        path.join(process.env.HOME || "~", "nexus", "home");
+    const createHomeLayout = false;
     // 1. Create workspace directory and Nexus state scaffolding
     const workspace = await ensureAgentWorkspace({
         dir: workspaceDir,
         ensureBootstrapFiles: true,
+        bootstrapMode: "minimal",
+        createHomeLayout,
     });
     runtime.log(`✓ Created workspace: ${workspace.dir}`);
     if (workspace.agentsPath)
         runtime.log(`  - ${path.basename(workspace.agentsPath)}`);
-    if (workspace.toolsPath)
+    if (workspace.toolsPath && createHomeLayout)
         runtime.log(`  - ${path.basename(workspace.toolsPath)}`);
     if (workspace.bootstrapPath)
         runtime.log(`  - ${path.basename(workspace.bootstrapPath)}`);
-    // 2. Create user skills/ directory (for personal custom skills)
+    await copyIdentityForInit({ env: process.env, runtime, workspace });
+    // 2. Resolve user skills directory (may be created later by user)
     const userSkillsDir = path.join(workspace.dir, "skills");
-    await fs.mkdir(userSkillsDir, { recursive: true });
-    runtime.log(`✓ Created user skills directory: ${userSkillsDir}`);
-    // 3. Create memory/ and projects/ directories
-    const memoryDir = path.join(workspace.dir, "memory");
-    await fs.mkdir(memoryDir, { recursive: true });
-    const projectsDir = path.join(workspace.dir, "projects");
-    await fs.mkdir(projectsDir, { recursive: true });
-    runtime.log(`✓ Created memory directory: ${memoryDir}`);
-    runtime.log(`✓ Created projects directory: ${projectsDir}`);
     // 4. Create state directory (~/nexus/state)
     const stateDir = resolveStateDir();
     await fs.mkdir(stateDir, { recursive: true });
@@ -131,10 +389,21 @@ export async function initCommand(opts, runtime = defaultRuntime) {
     };
     await fs.writeFile(workspaceMetaPath, JSON.stringify(workspaceMeta, null, 2), "utf-8");
     runtime.log(`✓ Created workspace metadata: ${workspaceMetaPath}`);
+    const configSnapshot = await readConfigFileSnapshot();
+    // 5b. Ensure credential index
+    await scanCredentials();
+    runtime.log(`✓ Created credential index: ${path.join(stateDir, "credentials", "index.json")}`);
     // 6. Create main skills directory (~/nexus/skills) and copy bundled skills
-    const skillsDir = path.join(NEXUS_ROOT, "skills");
+    const skillsDir = WORKSPACE_SKILLS_DIR;
     await fs.mkdir(skillsDir, { recursive: true });
+    await fs.mkdir(path.join(skillsDir, "tools"), { recursive: true });
+    await fs.mkdir(path.join(skillsDir, "connectors"), { recursive: true });
+    await fs.mkdir(path.join(skillsDir, "guides"), { recursive: true });
+    await fs.mkdir(path.join(skillsDir, "managed"), { recursive: true });
     runtime.log(`✓ Created skills directory: ${skillsDir}`);
+    // 6b. Create skills state directory (state/skills)
+    await fs.mkdir(SKILLS_STATE_DIR, { recursive: true });
+    runtime.log(`✓ Created skills state directory: ${SKILLS_STATE_DIR}`);
     // Copy bundled skills from installed package to ~/nexus/skills/
     const copyResult = await copyBundledSkills(skillsDir);
     if (copyResult.copied.length > 0) {
@@ -160,8 +429,23 @@ export async function initCommand(opts, runtime = defaultRuntime) {
         includeBootstrap: false,
     });
     runtime.log(`✓ Created Cursor rules: ${cursorRulesPath}`);
-    // 9. Initialize git repository for workspace
-    await initGitRepo(workspace.dir, runtime);
+    // 8b. Write Cursor hooks (sessionStart bootstrap)
+    const cursorHooks = await writeCursorHooks({ workspaceDir: NEXUS_ROOT });
+    if (cursorHooks.hooksCreated || cursorHooks.scriptCreated) {
+        runtime.log(`✓ Created Cursor hooks: ${cursorHooks.hooksPath}`);
+        if (cursorHooks.scriptCreated) {
+            runtime.log(`  - ${cursorHooks.scriptPath}`);
+        }
+    }
+    else {
+        runtime.log(`✓ Cursor hooks already present: ${cursorHooks.hooksPath}`);
+    }
+    // 9. Install and start gateway daemon
+    await ensureGatewayDaemon({
+        runtime,
+        env: process.env,
+        configSnapshot,
+    });
     runtime.log("\nNexus initialization complete!");
     runtime.log(`\nNext steps:\n  - Run 'nexus status' to orient\n  - Open ${NEXUS_ROOT} in your editor`);
 }

package/dist/commands/log.js

@@ -0,0 +1,134 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parseDurationMs } from "../cli/parse-duration.js";
+import { readSkillUsageEntries } from "../agents/skill-usage.js";
+import { resolveEventLogDir } from "../infra/event-log.js";
+import { defaultRuntime } from "../runtime.js";
+function parseSince(raw) {
+    if (!raw)
+        return undefined;
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return undefined;
+    const parsedDate = Date.parse(trimmed);
+    if (!Number.isNaN(parsedDate)) {
+        return parsedDate;
+    }
+    const ms = parseDurationMs(trimmed, { defaultUnit: "h" });
+    return Date.now() - ms;
+}
+function readEventFiles(dir) {
+    try {
+        return fs
+            .readdirSync(dir, { withFileTypes: true })
+            .filter((entry) => entry.isFile() &&
+            entry.name.startsWith("events-") &&
+            entry.name.endsWith(".jsonl"))
+            .map((entry) => entry.name)
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+function parseEventLine(line) {
+    try {
+        const parsed = JSON.parse(line);
+        if (!parsed || typeof parsed !== "object")
+            return null;
+        if (typeof parsed.ts !== "number")
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function loadEventLogEntries(opts) {
+    const dir = resolveEventLogDir();
+    const files = readEventFiles(dir);
+    const events = [];
+    for (const file of files) {
+        const filePath = path.join(dir, file);
+        let raw = "";
+        try {
+            raw = fs.readFileSync(filePath, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        for (const line of raw.split(/\r?\n/)) {
+            if (!line.trim())
+                continue;
+            const event = parseEventLine(line);
+            if (!event)
+                continue;
+            if (opts.sinceMs && event.ts < opts.sinceMs)
+                continue;
+            if (opts.source && event.source !== opts.source)
+                continue;
+            if (opts.command && event.command_path !== opts.command)
+                continue;
+            if (opts.errors) {
+                const isError = event.status === "error" ||
+                    event.event_type === "command_failed" ||
+                    event.event_type === "cli_session_end";
+                if (!isError)
+                    continue;
+            }
+            events.push(event);
+        }
+    }
+    if (opts.limit && opts.limit > 0 && events.length > opts.limit) {
+        return events.slice(-opts.limit);
+    }
+    return events;
+}
+export async function logCommand(opts, runtime = defaultRuntime) {
+    const sinceMs = parseSince(opts.since);
+    const limit = opts.limit && opts.limit > 0 ? opts.limit : undefined;
+    if (opts.skill) {
+        const entries = readSkillUsageEntries(opts.skill, {
+            sinceMs,
+            limit,
+        });
+        if (opts.json) {
+            runtime.log(JSON.stringify({ skill: opts.skill, entries }, null, 2));
+            return;
+        }
+        if (entries.length === 0) {
+            runtime.log("No skill usage found.");
+            return;
+        }
+        for (const entry of entries) {
+            const time = new Date(entry.ts).toISOString();
+            const status = entry.ok ? "ok" : "error";
+            const duration = typeof entry.durationMs === "number"
+                ? ` ${entry.durationMs}ms`
+                : "";
+            runtime.log(`${time} ${entry.event} ${status}${duration}`);
+        }
+        return;
+    }
+    const events = loadEventLogEntries({
+        sinceMs,
+        errors: opts.errors,
+        source: opts.source,
+        command: opts.command,
+        limit,
+    });
+    if (opts.json) {
+        runtime.log(JSON.stringify({ events }, null, 2));
+        return;
+    }
+    if (events.length === 0) {
+        runtime.log("No events found.");
+        return;
+    }
+    for (const event of events) {
+        const time = new Date(event.ts).toISOString();
+        const status = event.status ?? "-";
+        const command = event.command_path ?? event.event_type ?? "-";
+        runtime.log(`${time} ${event.source}:${command} ${status}`);
+    }
+}

package/dist/commands/models/fallbacks.js

@@ -1,4 +1,4 @@
-import { buildModelAliasIndex, resolveModelRefFromString } from "../../agents/model-selection.js";
+import { buildModelAliasIndex, resolveModelRefFromString, } from "../../agents/model-selection.js";
 import { CONFIG_PATH_NEXUS, loadConfig } from "../../config/config.js";
 import { DEFAULT_PROVIDER, ensureFlagCompatibility, modelKey, resolveModelTarget, updateConfig, } from "./shared.js";
 export async function modelsFallbacksListCommand(opts, runtime) {

package/dist/commands/models/image-fallbacks.js

@@ -1,4 +1,4 @@
-import { buildModelAliasIndex, resolveModelRefFromString } from "../../agents/model-selection.js";
+import { buildModelAliasIndex, resolveModelRefFromString, } from "../../agents/model-selection.js";
 import { CONFIG_PATH_NEXUS, loadConfig } from "../../config/config.js";
 import { DEFAULT_PROVIDER, ensureFlagCompatibility, modelKey, resolveModelTarget, updateConfig, } from "./shared.js";
 export async function modelsImageFallbacksListCommand(opts, runtime) {

package/dist/commands/models/list.js

@@ -5,7 +5,7 @@ import { ensureAuthProfileStore, listProfilesForProvider, } from "../../agents/a
 import { getCustomProviderApiKey, resolveEnvApiKey, } from "../../agents/model-auth.js";
 import { buildModelAliasIndex, parseModelRef, resolveConfiguredModelRef, resolveModelRefFromString, } from "../../agents/model-selection.js";
 import { ensureNexusModelsJson } from "../../agents/models-config.js";
-import { CONFIG_PATH_NEXUS, loadConfig } from "../../config/config.js";
+import { CONFIG_PATH_NEXUS, loadConfig, } from "../../config/config.js";
 import { info } from "../../globals.js";
 import { DEFAULT_MODEL, DEFAULT_PROVIDER, ensureFlagCompatibility, formatTokenK, modelKey, } from "./shared.js";
 const MODEL_PAD = 42;

package/dist/commands/models/scan.js

@@ -1,6 +1,6 @@
 import { cancel, isCancel, multiselect } from "@clack/prompts";
 import { resolveApiKeyForProvider } from "../../agents/model-auth.js";
-import { scanOpenRouterModels } from "../../agents/model-scan.js";
+import { scanOpenRouterModels, } from "../../agents/model-scan.js";
 import { CONFIG_PATH_NEXUS, loadConfig } from "../../config/config.js";
 import { formatMs, formatTokenK, updateConfig } from "./shared.js";
 const MODEL_PAD = 42;

package/dist/commands/onboard-auth.js

@@ -1,11 +1,36 @@
 import { upsertAuthProfile } from "../agents/auth-profiles.js";
 export async function writeOAuthCredentials(provider, creds) {
+    const access = "accessToken" in creds && typeof creds.accessToken === "string"
+        ? creds.accessToken
+        : typeof creds.access === "string"
+            ? creds.access
+            : undefined;
+    const refresh = "refreshToken" in creds && typeof creds.refreshToken === "string"
+        ? creds.refreshToken
+        : typeof creds.refresh === "string"
+            ? creds.refresh
+            : undefined;
+    const rawExpires = "expiresAt" in creds
+        ? creds.expiresAt
+        : creds.expires;
+    const parsedExpires = typeof rawExpires === "number"
+        ? rawExpires
+        : typeof rawExpires === "string"
+            ? Number.parseInt(rawExpires, 10)
+            : undefined;
+    const expires = typeof parsedExpires === "number" && Number.isFinite(parsedExpires)
+        ? parsedExpires
+        : undefined;
+    const email = typeof creds.email === "string" ? creds.email : undefined;
     upsertAuthProfile({
-        profileId: `${provider}:${creds.email ?? "default"}`,
+        profileId: `${provider}:${email ?? "default"}`,
         credential: {
             type: "oauth",
             provider,
-            ...creds,
+            access,
+            refresh,
+            expires,
+            email,
         },
     });
 }

package/dist/commands/onboard-eve-identity.js

@@ -5,7 +5,10 @@ const execFileAsync = promisify(execFile);
 function coerceStringArray(input) {
     if (!Array.isArray(input))
         return [];
-    return input.map((v) => String(v)).map((s) => s.trim()).filter(Boolean);
+    return input
+        .map((v) => String(v))
+        .map((s) => s.trim())
+        .filter(Boolean);
 }
 function parseEveWhoamiJson(stdout) {
     const raw = stdout.trim();
@@ -78,21 +81,17 @@ export async function maybeSetupIdentityFromEve(params) {
         await prompter.note(`Eve whoami failed: ${err instanceof Error ? err.message : String(err)}`, "Eve whoami");
         return;
     }
-    if (!whoami?.name && (!whoami?.phones?.length && !whoami?.emails?.length)) {
+    if (!whoami?.name && !whoami?.phones?.length && !whoami?.emails?.length) {
         await prompter.note("Eve ran, but didn't return identity info in a readable format.", "Eve whoami");
         return;
     }
     const summaryLines = [
         whoami.name ? `Name: ${whoami.name}` : undefined,
-        whoami.phones && whoami.phones.length
-            ? `Phones: ${whoami.phones.join(", ")}`
-            : undefined,
-        whoami.emails && whoami.emails.length
-            ? `Emails: ${whoami.emails.join(", ")}`
-            : undefined,
+        whoami.phones?.length ? `Phones: ${whoami.phones.join(", ")}` : undefined,
+        whoami.emails?.length ? `Emails: ${whoami.emails.join(", ")}` : undefined,
     ].filter(Boolean);
     await prompter.note(summaryLines.join("\n"), "Detected identity (Eve)");
-    // NOTE: We don't directly edit IDENTITY.md / PROFILE.md here yet; the bootstrap ritual
+    // NOTE: We don't directly edit agent/user IDENTITY.md here yet; the bootstrap ritual
     // should incorporate these values when it runs. Next step: write this into config
     // and/or workspace files once we agree on the exact schema + wording.
 }

package/dist/commands/onboard-non-interactive.js

@@ -5,9 +5,9 @@ import { resolveGatewayProgramArguments } from "../daemon/program-args.js";
 import { resolveGatewayService } from "../daemon/service.js";
 import { defaultRuntime } from "../runtime.js";
 import { resolveUserPath, sleep } from "../utils.js";
+import { applyBootstrapPreset } from "./bootstrap-preset.js";
 import { healthCommand } from "./health.js";
 import { applyAuthProfileConfig, applyMinimaxConfig, setAnthropicApiKey, } from "./onboard-auth.js";
-import { applyBootstrapPreset } from "./bootstrap-preset.js";
 import { applyWizardMetadata, DEFAULT_WORKSPACE, ensureWorkspaceAndSessions, randomToken, } from "./onboard-helpers.js";
 import { ensureSystemdUserLingerNonInteractive } from "./systemd-linger.js";
 export async function runNonInteractiveOnboarding(opts, runtime = defaultRuntime) {
@@ -180,7 +180,9 @@ export async function runNonInteractiveOnboarding(opts, runtime = defaultRuntime
         skipBootstrap: Boolean(nextConfig.agent?.skipBootstrap),
     });
     // Scripted bootstrap (test harness / automation): fill identity files + delete BOOTSTRAP.md.
-    if (opts.bootstrapPreset || opts.bootstrapAgentName || opts.bootstrapUserName) {
+    if (opts.bootstrapPreset ||
+        opts.bootstrapAgentName ||
+        opts.bootstrapUserName) {
         await applyBootstrapPreset({
             workspaceDir,
             runtime,