@ouro.bot/cli 0.1.0-alpha.9 → 0.1.0-alpha.91

package/dist/heart/providers/github-copilot.js

@@ -0,0 +1,149 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGithubCopilotProviderRuntime = createGithubCopilotProviderRuntime;
+const openai_1 = __importDefault(require("openai"));
+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");
+/* v8 ignore start -- auth guidance helpers: tested via mock-driven provider tests @preserve */
+function isAuthFailure(error) {
+    if (!(error instanceof Error))
+        return false;
+    const status = error.status;
+    return status === 401 || status === 403;
+}
+function getReauthGuidance(reason) {
+    const agentName = (0, identity_1.getAgentName)();
+    return [
+        `provider github-copilot failed (${reason}).`,
+        `Run \`ouro auth verify --agent ${agentName}\` to check all configured providers,`,
+        `\`ouro auth switch --agent ${agentName} --provider <other>\` to switch,`,
+        `or \`ouro auth --agent ${agentName} --provider github-copilot\` to reconfigure.`,
+    ].join(" ");
+}
+function withAuthGuidance(error) {
+    const base = error instanceof Error ? error.message : String(error);
+    if (isAuthFailure(error)) {
+        return new Error(getReauthGuidance(base));
+    }
+    return error instanceof Error ? error : new Error(String(error));
+}
+/* v8 ignore stop */
+function createGithubCopilotProviderRuntime() {
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.provider_init",
+        message: "github-copilot provider init",
+        meta: { provider: "github-copilot" },
+    });
+    const config = (0, config_1.getGithubCopilotConfig)();
+    if (!config.githubToken) {
+        throw new Error("provider 'github-copilot' is selected in agent.json but providers.github-copilot.githubToken is missing in secrets.json.");
+    }
+    if (!config.baseUrl) {
+        throw new Error("provider 'github-copilot' is selected in agent.json but providers.github-copilot.baseUrl is missing in secrets.json.");
+    }
+    const isCompletionsModel = config.model.startsWith("claude");
+    const modelCaps = (0, model_capabilities_1.getModelCapabilities)(config.model);
+    const capabilities = new Set();
+    /* v8 ignore next -- branch: capability detection tested via unit test @preserve */
+    if (modelCaps.reasoningEffort)
+        capabilities.add("reasoning-effort");
+    const client = new openai_1.default({
+        apiKey: config.githubToken,
+        baseURL: config.baseUrl,
+        timeout: 30000,
+        maxRetries: 0,
+    });
+    if (isCompletionsModel) {
+        // Chat completions path (Claude models via Copilot)
+        return {
+            id: "github-copilot",
+            model: config.model,
+            client,
+            capabilities,
+            supportedReasoningEfforts: modelCaps.reasoningEffort,
+            resetTurnState(_messages) {
+                // No provider-owned turn state for chat-completions path.
+            },
+            appendToolOutput(_callId, _output) {
+                // Chat-completions providers rely on canonical messages only.
+            },
+            /* v8 ignore start -- streamTurn: tested via mock assertions in github-copilot.test.ts @preserve */
+            async streamTurn(request) {
+                const params = {
+                    messages: request.messages,
+                    tools: request.activeTools,
+                    stream: true,
+                };
+                if (this.model)
+                    params.model = this.model;
+                if (request.traceId)
+                    params.metadata = { trace_id: request.traceId };
+                if (request.toolChoiceRequired)
+                    params.tool_choice = "required";
+                try {
+                    return await (0, streaming_1.streamChatCompletion)(this.client, params, request.callbacks, request.signal);
+                }
+                catch (error) {
+                    throw withAuthGuidance(error);
+                }
+            },
+            /* v8 ignore stop */
+        };
+    }
+    // Responses API path (GPT models via Copilot)
+    let nativeInput = null;
+    let nativeInstructions = "";
+    return {
+        id: "github-copilot",
+        model: config.model,
+        client,
+        capabilities,
+        supportedReasoningEfforts: modelCaps.reasoningEffort,
+        /* v8 ignore start -- responses path: tested via mock assertions in github-copilot.test.ts @preserve */
+        resetTurnState(messages) {
+            const { instructions, input } = (0, streaming_1.toResponsesInput)(messages);
+            nativeInput = input;
+            nativeInstructions = instructions;
+        },
+        appendToolOutput(callId, output) {
+            if (!nativeInput)
+                return;
+            nativeInput.push({ type: "function_call_output", call_id: callId, output });
+        },
+        async streamTurn(request) {
+            if (!nativeInput)
+                this.resetTurnState(request.messages);
+            const params = {
+                model: this.model,
+                input: nativeInput,
+                instructions: nativeInstructions,
+                tools: (0, streaming_1.toResponsesTools)(request.activeTools),
+                reasoning: { effort: request.reasoningEffort ?? "medium", summary: "detailed" },
+                stream: true,
+                store: false,
+                include: ["reasoning.encrypted_content"],
+            };
+            if (request.traceId)
+                params.metadata = { trace_id: request.traceId };
+            if (request.toolChoiceRequired)
+                params.tool_choice = "required";
+            try {
+                const result = await (0, streaming_1.streamResponsesApi)(this.client, params, request.callbacks, request.signal);
+                for (const item of result.outputItems)
+                    nativeInput.push(item);
+                return result;
+            }
+            catch (error) {
+                throw withAuthGuidance(error);
+            }
+        },
+        /* v8 ignore stop */
+    };
+}

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,362 @@
+"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;
+exports.resolveSafeShellExecution = resolveSafeShellExecution;
+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 workspaceSelectionStateFile(workspaceBase) {
+    return path.join(workspaceBase, ".active-safe-workspace.json");
+}
+function getOptionalFsFn(name) {
+    try {
+        return fs[name];
+    }
+    catch {
+        return undefined;
+    }
+}
+function shouldPersistSelection(options) {
+    return options.persistSelection ?? options.workspaceRoot === undefined;
+}
+function isPersistedSelectionShape(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const candidate = value;
+    return (typeof candidate.runtimeKind === "string"
+        && typeof candidate.repoRoot === "string"
+        && typeof candidate.workspaceRoot === "string"
+        && typeof candidate.workspaceBranch === "string"
+        && (candidate.sourceBranch === null || typeof candidate.sourceBranch === "string")
+        && typeof candidate.sourceCloneUrl === "string"
+        && typeof candidate.cleanupAfterMerge === "boolean"
+        && typeof candidate.created === "boolean"
+        && typeof candidate.note === "string");
+}
+function loadPersistedSelection(workspaceBase, options) {
+    const existsSync = options.existsSync ?? fs.existsSync;
+    const readFileSync = options.readFileSync ?? getOptionalFsFn("readFileSync");
+    const unlinkSync = options.unlinkSync ?? getOptionalFsFn("unlinkSync");
+    const stateFile = workspaceSelectionStateFile(workspaceBase);
+    if (!existsSync(stateFile))
+        return null;
+    if (!readFileSync)
+        return null;
+    try {
+        const raw = readFileSync(stateFile, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (!isPersistedSelectionShape(parsed) || !existsSync(parsed.workspaceRoot)) {
+            try {
+                unlinkSync?.(stateFile);
+            }
+            catch {
+                // best effort
+            }
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        try {
+            unlinkSync?.(stateFile);
+        }
+        catch {
+            // best effort
+        }
+        return null;
+    }
+}
+function persistSelectionState(workspaceBase, selection, options) {
+    const mkdirSync = options.mkdirSync ?? fs.mkdirSync;
+    const writeFileSync = options.writeFileSync ?? getOptionalFsFn("writeFileSync");
+    if (!writeFileSync)
+        return;
+    mkdirSync(workspaceBase, { recursive: true });
+    writeFileSync(workspaceSelectionStateFile(workspaceBase), JSON.stringify(selection, null, 2), "utf-8");
+}
+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, branchName };
+}
+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, branchName: "main" };
+}
+const REPO_LOCAL_SHELL_COMMAND = /^(?:[A-Za-z_][A-Za-z0-9_]*=\S+\s+)*(git|npm|npx|node|pnpm|yarn|bun|rg|sed|cat|ls|find|grep|vitest|tsc|eslint)\b/;
+function looksRepoLocalShellCommand(command) {
+    return REPO_LOCAL_SHELL_COMMAND.test(command.trim());
+}
+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 persistSelection = shouldPersistSelection(options);
+    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 });
+    if (persistSelection) {
+        const restored = loadPersistedSelection(workspaceBase, options);
+        if (restored) {
+            activeSelection = restored;
+            (0, runtime_1.emitNervesEvent)({
+                component: "workspace",
+                event: "workspace.safe_repo_restored",
+                message: "restored safe repo workspace after runtime restart",
+                meta: {
+                    runtimeKind: restored.runtimeKind,
+                    repoRoot: restored.repoRoot,
+                    workspaceRoot: restored.workspaceRoot,
+                    workspaceBranch: restored.workspaceBranch,
+                    sourceBranch: restored.sourceBranch,
+                    cleanupAfterMerge: restored.cleanupAfterMerge,
+                },
+            });
+            return restored;
+        }
+    }
+    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,
+                workspaceBranch: created.branchName,
+                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,
+                workspaceBranch: created.branchName,
+                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,
+            workspaceBranch: created.branchName,
+            sourceBranch: null,
+            sourceCloneUrl: canonicalRepoUrl,
+            cleanupAfterMerge: true,
+            created: created.created,
+            note: `running from installed runtime/wrapper; created scratch clone ${created.workspaceRoot} from ${canonicalRepoUrl}`,
+        };
+    }
+    activeSelection = selection;
+    if (persistSelection) {
+        persistSelectionState(workspaceBase, selection, options);
+    }
+    (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,
+            workspaceBranch: selection.workspaceBranch,
+            sourceBranch: selection.sourceBranch,
+            sourceCloneUrl: selection.sourceCloneUrl,
+            cleanupAfterMerge: selection.cleanupAfterMerge,
+        },
+    });
+    return selection;
+}
+function resolveSafeRepoPath(options) {
+    const rawRequestedPath = options.requestedPath;
+    const repoRoot = path.resolve(options.repoRoot ?? (0, identity_1.getRepoRoot)());
+    if (!path.isAbsolute(rawRequestedPath) && !rawRequestedPath.startsWith("~")) {
+        const selection = activeSelection ?? ensureSafeRepoWorkspace(options);
+        return {
+            selection,
+            resolvedPath: path.resolve(selection.workspaceRoot, rawRequestedPath),
+        };
+    }
+    const requestedPath = path.resolve(rawRequestedPath);
+    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 };
+}
+function resolveSafeShellExecution(command, options = {}) {
+    const trimmed = command.trim();
+    if (!trimmed) {
+        return { selection: activeSelection, command };
+    }
+    if (activeSelection && command.includes(activeSelection.workspaceRoot)) {
+        return { selection: activeSelection, command, cwd: activeSelection.workspaceRoot };
+    }
+    const repoRoot = path.resolve(options.repoRoot ?? (0, identity_1.getRepoRoot)());
+    const mentionsRepoRoot = command.includes(repoRoot);
+    const shouldRoute = mentionsRepoRoot || looksRepoLocalShellCommand(trimmed);
+    if (!shouldRoute) {
+        return { selection: activeSelection, command };
+    }
+    const selection = ensureSafeRepoWorkspace(options);
+    const rewrittenCommand = mentionsRepoRoot
+        ? command.split(repoRoot).join(selection.workspaceRoot)
+        : command;
+    return {
+        selection,
+        command: rewrittenCommand,
+        cwd: selection.workspaceRoot,
+    };
+}

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;
+}