@ouro.bot/cli 0.1.0-alpha.6 → 0.1.0-alpha.60

package/dist/heart/providers/anthropic.js

@@ -3,11 +3,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.toAnthropicMessages = toAnthropicMessages;
 exports.createAnthropicProviderRuntime = createAnthropicProviderRuntime;
 const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
 const config_1 = require("../config");
 const identity_1 = require("../identity");
 const runtime_1 = require("../../nerves/runtime");
+const streaming_1 = require("../streaming");
+const model_capabilities_1 = require("../model-capabilities");
 const ANTHROPIC_SETUP_TOKEN_PREFIX = "sk-ant-oat01-";
 const ANTHROPIC_SETUP_TOKEN_MIN_LENGTH = 80;
 const ANTHROPIC_OAUTH_BETA_HEADER = "claude-code-20250219,oauth-2025-04-20,fine-grained-tool-streaming-2025-05-14,interleaved-thinking-2025-05-14";
@@ -21,10 +24,10 @@ function getAnthropicSetupTokenInstructions() {
     const agentName = getAnthropicAgentNameForGuidance();
     return [
         "Fix:",
-        `  1. Run \`npm run auth:claude-setup-token -- --agent ${agentName}\``,
-        "     (or run `claude setup-token` and paste the token manually)",
+        `  1. Run \`ouro auth --agent ${agentName}\``,
         `  2. Open ${getAnthropicSecretsPathForGuidance()}`,
         "  3. Confirm providers.anthropic.setupToken is set",
+        "  4. After reauth, retry the failed ouro command or reconnect this session.",
     ].join("\n");
 }
 function getAnthropicReauthGuidance(reason) {
@@ -92,6 +95,18 @@ function toAnthropicMessages(messages) {
         if (msg.role === "assistant") {
             const assistant = msg;
             const blocks = [];
+            // Restore thinking blocks before text/tool_use blocks
+            const thinkingBlocks = assistant._thinking_blocks;
+            if (thinkingBlocks) {
+                for (const tb of thinkingBlocks) {
+                    if (tb.type === "thinking") {
+                        blocks.push({ type: "thinking", thinking: tb.thinking, signature: tb.signature });
+                    }
+                    else {
+                        blocks.push({ type: "redacted_thinking", data: tb.data });
+                    }
+                }
+            }
             const text = toAnthropicTextContent(assistant.content);
             if (text) {
                 blocks.push({ type: "text", text });
@@ -194,11 +209,14 @@ function withAnthropicAuthGuidance(error) {
 async function streamAnthropicMessages(client, model, request) {
     const { system, messages } = toAnthropicMessages(request.messages);
     const anthropicTools = toAnthropicTools(request.activeTools);
+    const modelCaps = (0, model_capabilities_1.getModelCapabilities)(model);
+    const maxTokens = modelCaps.maxOutputTokens ?? 16384;
     const params = {
         model,
-        max_tokens: 4096,
+        max_tokens: maxTokens,
         messages,
         stream: true,
+        thinking: { type: "adaptive", effort: request.reasoningEffort ?? "medium" },
     };
     if (system)
         params.system = system;
@@ -218,6 +236,9 @@ async function streamAnthropicMessages(client, model, request) {
     let streamStarted = false;
     let usage;
     const toolCalls = new Map();
+    const thinkingBlocks = new Map();
+    const redactedBlocks = new Map();
+    const answerStreamer = new streaming_1.FinalAnswerStreamer(request.callbacks);
     try {
         for await (const event of response) {
             if (request.signal?.aborted)
@@ -225,17 +246,29 @@ async function streamAnthropicMessages(client, model, request) {
             const eventType = String(event.type ?? "");
             if (eventType === "content_block_start") {
                 const block = event.content_block;
-                if (block?.type === "tool_use") {
-                    const index = Number(event.index);
+                const index = Number(event.index);
+                if (block?.type === "thinking") {
+                    thinkingBlocks.set(index, { type: "thinking", thinking: "", signature: "" });
+                }
+                else if (block?.type === "redacted_thinking") {
+                    redactedBlocks.set(index, { type: "redacted_thinking", data: String(block.data ?? "") });
+                }
+                else if (block?.type === "tool_use") {
                     const rawInput = block.input;
                     const input = rawInput && typeof rawInput === "object"
                         ? JSON.stringify(rawInput)
                         : "";
+                    const name = String(block.name ?? "");
                     toolCalls.set(index, {
                         id: String(block.id ?? ""),
-                        name: String(block.name ?? ""),
+                        name,
                         arguments: input,
                     });
+                    // Activate eager streaming for sole final_answer tool call
+                    /* v8 ignore next -- final_answer streaming activation, tested via FinalAnswerStreamer unit tests @preserve */
+                    if (name === "final_answer" && toolCalls.size === 1) {
+                        answerStreamer.activate();
+                    }
                 }
                 continue;
             }
@@ -257,14 +290,31 @@ async function streamAnthropicMessages(client, model, request) {
                         request.callbacks.onModelStreamStart();
                         streamStarted = true;
                     }
-                    request.callbacks.onReasoningChunk(String(delta?.thinking ?? ""));
+                    const thinkingText = String(delta?.thinking ?? "");
+                    request.callbacks.onReasoningChunk(thinkingText);
+                    const thinkingIndex = Number(event.index);
+                    const thinkingBlock = thinkingBlocks.get(thinkingIndex);
+                    if (thinkingBlock)
+                        thinkingBlock.thinking += thinkingText;
+                    continue;
+                }
+                if (deltaType === "signature_delta") {
+                    const sigIndex = Number(event.index);
+                    const sigBlock = thinkingBlocks.get(sigIndex);
+                    if (sigBlock)
+                        sigBlock.signature += String(delta?.signature ?? "");
                     continue;
                 }
                 if (deltaType === "input_json_delta") {
                     const index = Number(event.index);
                     const existing = toolCalls.get(index);
                     if (existing) {
-                        existing.arguments = mergeAnthropicToolArguments(existing.arguments, String(delta?.partial_json ?? ""));
+                        const partialJson = String(delta?.partial_json ?? "");
+                        existing.arguments = mergeAnthropicToolArguments(existing.arguments, partialJson);
+                        /* v8 ignore next -- final_answer delta streaming, tested via FinalAnswerStreamer unit tests @preserve */
+                        if (existing.name === "final_answer" && toolCalls.size === 1) {
+                            answerStreamer.processDelta(partialJson);
+                        }
                     }
                     continue;
                 }
@@ -288,11 +338,20 @@ async function streamAnthropicMessages(client, model, request) {
     catch (error) {
         throw withAnthropicAuthGuidance(error);
     }
+    // Collect all thinking blocks (regular + redacted) sorted by index to preserve ordering
+    const allThinkingIndices = [...thinkingBlocks.keys(), ...redactedBlocks.keys()].sort((a, b) => a - b);
+    const outputItems = allThinkingIndices.map((idx) => {
+        const tb = thinkingBlocks.get(idx);
+        if (tb)
+            return tb;
+        return redactedBlocks.get(idx);
+    });
     return {
         content,
         toolCalls: [...toolCalls.values()],
-        outputItems: [],
+        outputItems,
         usage,
+        finalAnswerStreamed: answerStreamer.streamed,
     };
 }
 function createAnthropicProviderRuntime() {
@@ -306,6 +365,10 @@ function createAnthropicProviderRuntime() {
     if (!(anthropicConfig.model && anthropicConfig.setupToken)) {
         throw new Error(getAnthropicReauthGuidance("provider 'anthropic' is selected in agent.json but providers.anthropic.model/setupToken is incomplete in secrets.json."));
     }
+    const modelCaps = (0, model_capabilities_1.getModelCapabilities)(anthropicConfig.model);
+    const capabilities = new Set();
+    if (modelCaps.reasoningEffort)
+        capabilities.add("reasoning-effort");
     const credential = resolveAnthropicSetupTokenCredential();
     const client = new sdk_1.default({
         authToken: credential.token,
@@ -319,6 +382,8 @@ function createAnthropicProviderRuntime() {
         id: "anthropic",
         model: anthropicConfig.model,
         client,
+        capabilities,
+        supportedReasoningEfforts: modelCaps.reasoningEffort,
         resetTurnState(_messages) {
             // Anthropic request payload is derived from canonical messages each turn.
         },

package/dist/heart/providers/azure.js

@@ -1,35 +1,114 @@
 "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.createAzureTokenProvider = createAzureTokenProvider;
 exports.createAzureProviderRuntime = createAzureProviderRuntime;
 const openai_1 = require("openai");
 const config_1 = require("../config");
 const runtime_1 = require("../../nerves/runtime");
 const streaming_1 = require("../streaming");
+const model_capabilities_1 = require("../model-capabilities");
+const COGNITIVE_SERVICES_SCOPE = "https://cognitiveservices.azure.com/.default";
+// @azure/identity is imported dynamically (below) rather than at the top level
+// because it's a heavy package (~30+ transitive deps) and we only need it when
+// using the managed-identity auth path. API-key users and other providers
+// shouldn't pay the cold-start cost.
+function createAzureTokenProvider(managedIdentityClientId) {
+    let credential = null;
+    return async () => {
+        try {
+            if (!credential) {
+                const { DefaultAzureCredential } = await Promise.resolve().then(() => __importStar(require("@azure/identity")));
+                const credentialOptions = managedIdentityClientId
+                    ? { managedIdentityClientId }
+                    : undefined;
+                credential = new DefaultAzureCredential(credentialOptions);
+            }
+            const tokenResponse = await credential.getToken(COGNITIVE_SERVICES_SCOPE);
+            return tokenResponse.token;
+        }
+        catch (err) {
+            const detail = err instanceof Error ? err.message : String(err);
+            throw new Error(`Azure OpenAI authentication failed: ${detail}\n` +
+                "To fix this, either:\n" +
+                "  1. Set providers.azure.apiKey in secrets.json, or\n" +
+                "  2. Run 'az login' to authenticate with your Azure account (for local dev), or\n" +
+                "  3. Attach a managed identity to your App Service and set providers.azure.managedIdentityClientId in secrets.json (for deployed environments)");
+        }
+    };
+}
 function createAzureProviderRuntime() {
+    const azureConfig = (0, config_1.getAzureConfig)();
+    const useApiKey = !!azureConfig.apiKey;
+    const authMethod = useApiKey ? "key" : "managed-identity";
     (0, runtime_1.emitNervesEvent)({
         component: "engine",
         event: "engine.provider_init",
         message: "azure provider init",
-        meta: { provider: "azure" },
+        meta: { provider: "azure", authMethod },
     });
-    const azureConfig = (0, config_1.getAzureConfig)();
-    if (!(azureConfig.apiKey && azureConfig.endpoint && azureConfig.deployment && azureConfig.modelName)) {
+    if (!(azureConfig.endpoint && azureConfig.deployment && azureConfig.modelName)) {
         throw new Error("provider 'azure' is selected in agent.json but providers.azure is incomplete in secrets.json.");
     }
-    const client = new openai_1.AzureOpenAI({
-        apiKey: azureConfig.apiKey,
+    const modelCaps = (0, model_capabilities_1.getModelCapabilities)(azureConfig.modelName);
+    const capabilities = new Set();
+    if (modelCaps.reasoningEffort)
+        capabilities.add("reasoning-effort");
+    const clientOptions = {
         endpoint: azureConfig.endpoint.replace(/\/openai.*$/, ""),
         deployment: azureConfig.deployment,
         apiVersion: azureConfig.apiVersion,
         timeout: 30000,
         maxRetries: 0,
-    });
+    };
+    if (useApiKey) {
+        clientOptions.apiKey = azureConfig.apiKey;
+    }
+    else {
+        const managedIdentityClientId = azureConfig.managedIdentityClientId || undefined;
+        clientOptions.azureADTokenProvider = createAzureTokenProvider(managedIdentityClientId);
+    }
+    const client = new openai_1.AzureOpenAI(clientOptions);
     let nativeInput = null;
     let nativeInstructions = "";
     return {
         id: "azure",
         model: azureConfig.modelName,
         client,
+        capabilities,
+        supportedReasoningEfforts: modelCaps.reasoningEffort,
         resetTurnState(messages) {
             const { instructions, input } = (0, streaming_1.toResponsesInput)(messages);
             nativeInput = input;
@@ -48,7 +127,7 @@ function createAzureProviderRuntime() {
                 input: nativeInput,
                 instructions: nativeInstructions,
                 tools: (0, streaming_1.toResponsesTools)(request.activeTools),
-                reasoning: { effort: "medium", summary: "detailed" },
+                reasoning: { effort: request.reasoningEffort ?? "medium", summary: "detailed" },
                 stream: true,
                 store: false,
                 include: ["reasoning.encrypted_content"],

package/dist/heart/providers/minimax.js

@@ -8,6 +8,7 @@ const openai_1 = __importDefault(require("openai"));
 const config_1 = require("../config");
 const runtime_1 = require("../../nerves/runtime");
 const streaming_1 = require("../streaming");
+const model_capabilities_1 = require("../model-capabilities");
 function createMinimaxProviderRuntime() {
     (0, runtime_1.emitNervesEvent)({
         component: "engine",
@@ -19,6 +20,8 @@ function createMinimaxProviderRuntime() {
     if (!minimaxConfig.apiKey) {
         throw new Error("provider 'minimax' is selected in agent.json but providers.minimax.apiKey is missing in secrets.json.");
     }
+    // Registry consulted; MiniMax models return empty defaults (no capabilities to derive)
+    (0, model_capabilities_1.getModelCapabilities)(minimaxConfig.model);
     const client = new openai_1.default({
         apiKey: minimaxConfig.apiKey,
         baseURL: "https://api.minimaxi.chat/v1",
@@ -29,6 +32,7 @@ function createMinimaxProviderRuntime() {
         id: "minimax",
         model: minimaxConfig.model,
         client,
+        capabilities: new Set(),
         resetTurnState(_messages) {
             // No provider-owned turn state for chat-completions providers.
         },

package/dist/heart/providers/openai-codex.js

@@ -9,6 +9,7 @@ const config_1 = require("../config");
 const identity_1 = require("../identity");
 const runtime_1 = require("../../nerves/runtime");
 const streaming_1 = require("../streaming");
+const model_capabilities_1 = require("../model-capabilities");
 const OPENAI_CODEX_AUTH_FAILURE_MARKERS = [
     "authentication failed",
     "unauthorized",
@@ -27,11 +28,11 @@ function getOpenAICodexOAuthInstructions() {
     const agentName = getOpenAICodexAgentNameForGuidance();
     return [
         "Fix:",
-        `  1. Run \`npm run auth:openai-codex -- --agent ${agentName}\``,
-        "     (or run `codex login` and set the OAuth token manually)",
+        `  1. Run \`ouro auth --agent ${agentName}\``,
         `  2. Open ${getOpenAICodexSecretsPathForGuidance()}`,
         "  3. Confirm providers.openai-codex.oauthAccessToken is set",
         "  4. This provider uses chatgpt.com/backend-api/codex/responses (not api.openai.com/responses).",
+        "  5. After reauth, retry the failed ouro command or reconnect this session.",
     ].join("\n");
 }
 function getOpenAICodexReauthGuidance(reason) {
@@ -106,6 +107,12 @@ function createOpenAICodexProviderRuntime() {
     if (!chatgptAccountId) {
         throw new Error(getOpenAICodexReauthGuidance("OpenAI Codex OAuth access token is missing a chatgpt_account_id claim required for chatgpt.com/backend-api/codex."));
     }
+    const modelCaps = (0, model_capabilities_1.getModelCapabilities)(codexConfig.model);
+    const capabilities = new Set();
+    if (modelCaps.reasoningEffort)
+        capabilities.add("reasoning-effort");
+    if (modelCaps.phase)
+        capabilities.add("phase-annotation");
     const client = new openai_1.default({
         apiKey: token,
         baseURL: OPENAI_CODEX_BACKEND_BASE_URL,
@@ -123,6 +130,8 @@ function createOpenAICodexProviderRuntime() {
         id: "openai-codex",
         model: codexConfig.model,
         client,
+        capabilities,
+        supportedReasoningEfforts: modelCaps.reasoningEffort,
         resetTurnState(messages) {
             const { instructions, input } = (0, streaming_1.toResponsesInput)(messages);
             nativeInput = input;
@@ -141,7 +150,7 @@ function createOpenAICodexProviderRuntime() {
                 input: nativeInput,
                 instructions: nativeInstructions,
                 tools: (0, streaming_1.toResponsesTools)(request.activeTools),
-                reasoning: { effort: "medium", summary: "detailed" },
+                reasoning: { effort: request.reasoningEffort ?? "medium", summary: "detailed" },
                 stream: true,
                 store: false,
                 include: ["reasoning.encrypted_content"],

package/dist/heart/safe-workspace.js

@@ -0,0 +1,228 @@
+"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/sense-truth.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSenseInventory = getSenseInventory;
+const runtime_1 = require("../nerves/runtime");
+const identity_1 = require("./identity");
+const SENSES = [
+    { sense: "cli", label: "CLI", daemonManaged: false },
+    { sense: "teams", label: "Teams", daemonManaged: true },
+    { sense: "bluebubbles", label: "BlueBubbles", daemonManaged: true },
+];
+function configuredSenses(senses) {
+    return senses ?? {
+        cli: { ...identity_1.DEFAULT_AGENT_SENSES.cli },
+        teams: { ...identity_1.DEFAULT_AGENT_SENSES.teams },
+        bluebubbles: { ...identity_1.DEFAULT_AGENT_SENSES.bluebubbles },
+    };
+}
+function resolveStatus(enabled, daemonManaged, runtimeInfo) {
+    if (!enabled) {
+        return "disabled";
+    }
+    if (!daemonManaged) {
+        return "interactive";
+    }
+    if (runtimeInfo?.runtime === "error") {
+        return "error";
+    }
+    if (runtimeInfo?.runtime === "running") {
+        return "running";
+    }
+    if (runtimeInfo?.configured === false) {
+        return "needs_config";
+    }
+    return "ready";
+}
+function getSenseInventory(agent, runtime = {}) {
+    const senses = configuredSenses(agent.senses);
+    const inventory = SENSES.map(({ sense, label, daemonManaged }) => {
+        const enabled = senses[sense].enabled;
+        return {
+            sense,
+            label,
+            enabled,
+            daemonManaged,
+            status: resolveStatus(enabled, daemonManaged, runtime[sense]),
+        };
+    });
+    (0, runtime_1.emitNervesEvent)({
+        component: "channels",
+        event: "channel.sense_inventory_built",
+        message: "built sense inventory",
+        meta: {
+            senses: inventory.map((entry) => ({
+                sense: entry.sense,
+                enabled: entry.enabled,
+                status: entry.status,
+            })),
+        },
+    });
+    return inventory;
+}