@ouro.bot/cli 0.1.0-alpha.58 → 0.1.0-alpha.59

package/changelog.json

@@ -1,6 +1,14 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.59",
+      "changes": [
+        "Repo file edits now acquire a safe workspace before local tool writes, creating a dedicated worktree from `origin/main` when running from a clone and a scratch clone from the canonical GitHub source when running from an installed runtime.",
+        "The harness now has bundle-local workspace primitives for repo work plus bundle-local daemon logs, daemon logging config, message routing storage, and tool caches instead of leaning on `~/.agentstate` paths.",
+        "Coverage/test-run artifacts and related runtime expectations now use the new non-`~/.agentstate` locations, and daemon/tool tests cover the safe workspace decision table and the bundle-local path migration."
+      ]
+    },
     {
       "version": "0.1.0-alpha.58",
       "changes": [

package/dist/heart/daemon/daemon-cli.js

@@ -790,7 +790,7 @@ function defaultEnsureDaemonBootPersistence(socketPath) {
             meta: { entryPath },
         });
     }
-    const logDir = path.join(homeDir, ".agentstate", "daemon", "logs");
+    const logDir = (0, identity_1.getAgentDaemonLogsDir)();
     (0, launchd_1.installLaunchAgent)(launchdDeps, {
         nodePath: process.execPath,
         entryPath,

package/dist/heart/daemon/daemon.js

@@ -405,7 +405,7 @@ class OuroDaemon {
                     ok: true,
                     summary: "logs: use `ouro logs` to tail daemon and agent output",
                     message: "log streaming available via ouro logs",
-                    data: { logDir: "~/.agentstate/daemon/logs" },
+                    data: { logDir: "~/AgentBundles/<agent>.ouro/state/daemon/logs" },
                 };
             case "agent.start":
                 await this.processManager.startAgent(command.agent);

package/dist/heart/daemon/log-tailer.js

@@ -37,10 +37,10 @@ exports.discoverLogFiles = discoverLogFiles;
 exports.readLastLines = readLastLines;
 exports.formatLogLine = formatLogLine;
 exports.tailLogs = tailLogs;
-const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const nerves_1 = require("../../nerves");
 const runtime_1 = require("../../nerves/runtime");
+const identity_1 = require("../identity");
 const LEVEL_COLORS = {
     debug: "\x1b[2m",
     info: "\x1b[36m",
@@ -49,11 +49,12 @@ const LEVEL_COLORS = {
 };
 function discoverLogFiles(options) {
     /* v8 ignore start -- integration: default DI stubs for real OS @preserve */
-    const homeDir = options.homeDir ?? os.homedir();
     const existsSync = options.existsSync ?? (() => false);
     const readdirSync = options.readdirSync ?? (() => []);
     /* v8 ignore stop */
-    const logDir = path.join(homeDir, ".agentstate", "daemon", "logs");
+    const logDir = options.homeDir
+        ? path.join(options.homeDir, "AgentBundles", `${options.agentName ?? "slugger"}.ouro`, "state", "daemon", "logs")
+        : (0, identity_1.getAgentDaemonLogsDir)(options.agentName);
     const files = [];
     if (existsSync(logDir)) {
         for (const name of readdirSync(logDir)) {

package/dist/heart/daemon/message-router.js

@@ -35,9 +35,9 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FileMessageRouter = void 0;
 const fs = __importStar(require("fs"));
-const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const runtime_1 = require("../../nerves/runtime");
+const identity_1 = require("../identity");
 function messageId(nowIso) {
     return `msg-${nowIso.replace(/[^0-9]/g, "")}`;
 }
@@ -45,7 +45,7 @@ class FileMessageRouter {
     baseDir;
     now;
     constructor(options = {}) {
-        this.baseDir = options.baseDir ?? path.join(os.homedir(), ".agentstate", "messages");
+        this.baseDir = options.baseDir ?? (0, identity_1.getAgentMessagesRoot)();
         this.now = options.now ?? (() => new Date().toISOString());
         fs.mkdirSync(this.baseDir, { recursive: true });
     }

package/dist/heart/daemon/runtime-logging.js

@@ -35,10 +35,10 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.configureDaemonRuntimeLogger = configureDaemonRuntimeLogger;
 const fs = __importStar(require("fs"));
-const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const nerves_1 = require("../../nerves");
 const runtime_1 = require("../../nerves/runtime");
+const identity_1 = require("../identity");
 const LEGACY_SHARED_RUNTIME_LOGGING = {
     level: "info",
     sinks: ["terminal", "ndjson"],
@@ -99,15 +99,31 @@ function resolveRuntimeLoggingConfig(configPath, processName) {
         sinks,
     };
 }
+function resolveAgentNameForPaths(explicit) {
+    if (explicit && explicit.trim().length > 0)
+        return explicit.trim();
+    try {
+        return (0, identity_1.getAgentName)();
+    }
+    catch {
+        return "slugger";
+    }
+}
 function configureDaemonRuntimeLogger(processName, options = {}) {
-    const homeDir = options.homeDir ?? os.homedir();
-    const configPath = options.configPath ?? path.join(homeDir, ".agentstate", "daemon", "logging.json");
+    const agentName = resolveAgentNameForPaths(options.agentName);
+    const configPath = options.configPath
+        ?? (options.homeDir
+            ? path.join(options.homeDir, "AgentBundles", `${agentName}.ouro`, "state", "daemon", "logging.json")
+            : (0, identity_1.getAgentDaemonLoggingConfigPath)(agentName));
     const config = resolveRuntimeLoggingConfig(configPath, processName);
+    const logsDir = options.homeDir
+        ? path.join(options.homeDir, "AgentBundles", `${agentName}.ouro`, "state", "daemon", "logs")
+        : (0, identity_1.getAgentDaemonLogsDir)(agentName);
     const sinks = config.sinks.map((sinkName) => {
         if (sinkName === "terminal") {
             return (0, nerves_1.createTerminalSink)();
         }
-        const ndjsonPath = path.join(homeDir, ".agentstate", "daemon", "logs", `${processName}.ndjson`);
+        const ndjsonPath = path.join(logsDir, `${processName}.ndjson`);
         return (0, nerves_1.createNdjsonFileSink)(ndjsonPath);
     });
     const logger = (0, nerves_1.createLogger)({

package/dist/heart/daemon/runtime-metadata.js

@@ -174,7 +174,7 @@ function getRuntimeMetadata(deps = {}) {
     const bundlesRoot = deps.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
     const homeDir = readHomeDir();
     const secretsRoot = deps.secretsRoot ?? (homeDir ? path.join(homeDir, ".agentsecrets") : null);
-    const daemonLoggingPath = deps.daemonLoggingPath ?? (homeDir ? path.join(homeDir, ".agentstate", "daemon", "logging.json") : null);
+    const daemonLoggingPath = deps.daemonLoggingPath ?? (0, identity_1.getAgentDaemonLoggingConfigPath)();
     const readFileSyncImpl = deps.readFileSync ?? optionalFunction(fs, "readFileSync")?.bind(fs) ?? null;
     const statSyncImpl = deps.statSync ?? optionalFunction(fs, "statSync")?.bind(fs) ?? null;
     const readdirSyncImpl = deps.readdirSync ?? optionalFunction(fs, "readdirSync")?.bind(fs) ?? null;

package/dist/heart/identity.js

@@ -33,13 +33,19 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_AGENT_SENSES = exports.DEFAULT_AGENT_PHRASES = exports.DEFAULT_AGENT_CONTEXT = void 0;
+exports.HARNESS_CANONICAL_REPO_URL = exports.DEFAULT_AGENT_SENSES = exports.DEFAULT_AGENT_PHRASES = exports.DEFAULT_AGENT_CONTEXT = void 0;
 exports.buildDefaultAgentTemplate = buildDefaultAgentTemplate;
 exports.getAgentName = getAgentName;
 exports.getRepoRoot = getRepoRoot;
 exports.getAgentBundlesRoot = getAgentBundlesRoot;
 exports.getAgentRoot = getAgentRoot;
 exports.getAgentStateRoot = getAgentStateRoot;
+exports.getAgentRepoWorkspacesRoot = getAgentRepoWorkspacesRoot;
+exports.getAgentDaemonStateRoot = getAgentDaemonStateRoot;
+exports.getAgentDaemonLogsDir = getAgentDaemonLogsDir;
+exports.getAgentDaemonLoggingConfigPath = getAgentDaemonLoggingConfigPath;
+exports.getAgentMessagesRoot = getAgentMessagesRoot;
+exports.getAgentToolsRoot = getAgentToolsRoot;
 exports.getAgentSecretsPath = getAgentSecretsPath;
 exports.loadAgentConfig = loadAgentConfig;
 exports.setAgentName = setAgentName;
@@ -184,11 +190,40 @@ function getAgentBundlesRoot() {
 function getAgentRoot(agentName = getAgentName()) {
     return path.join(getAgentBundlesRoot(), `${agentName}.ouro`);
 }
+function resolveOptionalAgentName(agentName) {
+    if (agentName && agentName.trim().length > 0)
+        return agentName.trim();
+    try {
+        return getAgentName();
+    }
+    catch {
+        return "slugger";
+    }
+}
 /**
  * Returns the bundle-local runtime state directory: `~/AgentBundles/<agentName>.ouro/state/`
  */
-function getAgentStateRoot(agentName = getAgentName()) {
-    return path.join(getAgentRoot(agentName), "state");
+function getAgentStateRoot(agentName) {
+    return path.join(getAgentRoot(resolveOptionalAgentName(agentName)), "state");
+}
+exports.HARNESS_CANONICAL_REPO_URL = "https://github.com/ouroborosbot/ouroboros.git";
+function getAgentRepoWorkspacesRoot(agentName) {
+    return path.join(getAgentStateRoot(resolveOptionalAgentName(agentName)), "workspaces");
+}
+function getAgentDaemonStateRoot(agentName) {
+    return path.join(getAgentStateRoot(resolveOptionalAgentName(agentName)), "daemon");
+}
+function getAgentDaemonLogsDir(agentName) {
+    return path.join(getAgentDaemonStateRoot(resolveOptionalAgentName(agentName)), "logs");
+}
+function getAgentDaemonLoggingConfigPath(agentName) {
+    return path.join(getAgentDaemonStateRoot(resolveOptionalAgentName(agentName)), "logging.json");
+}
+function getAgentMessagesRoot(agentName) {
+    return path.join(getAgentStateRoot(resolveOptionalAgentName(agentName)), "messages");
+}
+function getAgentToolsRoot(agentName) {
+    return path.join(getAgentStateRoot(resolveOptionalAgentName(agentName)), "tools");
 }
 /**
  * Returns the conventional secrets path: `~/.agentsecrets/<agentName>/secrets.json`

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/nerves/coverage/run-artifacts.js

@@ -14,7 +14,7 @@ const path_1 = require("path");
 const os_1 = require("os");
 exports.REPO_SLUG = "ouroboros-agent-harness";
 function getTestRunsRoot(repoSlug = exports.REPO_SLUG) {
-    return (0, path_1.join)((0, os_1.homedir)(), ".agentstate", "test-runs", repoSlug);
+    return (0, path_1.join)((0, os_1.tmpdir)(), "ouroboros-test-runs", repoSlug);
 }
 function createRunId(now = new Date()) {
     return now.toISOString().replace(/[:.]/g, "-");

package/dist/repertoire/tools-base.js

@@ -42,6 +42,7 @@ const skills_1 = require("./skills");
 const config_1 = require("../heart/config");
 const runtime_1 = require("../nerves/runtime");
 const identity_1 = require("../heart/identity");
+const safe_workspace_1 = require("../heart/safe-workspace");
 const socket_client_1 = require("../heart/daemon/socket-client");
 const thoughts_1 = require("../heart/daemon/thoughts");
 const manager_1 = require("../heart/bridges/manager");
@@ -65,6 +66,9 @@ function buildContextDiff(lines, changeStart, changeEnd, contextSize = 3) {
     }
     return result.join("\n");
 }
+function resolveLocalToolPath(targetPath) {
+    return (0, safe_workspace_1.resolveSafeRepoPath)({ requestedPath: targetPath }).resolvedPath;
+}
 const NO_SESSION_FOUND_MESSAGE = "no session found for that friend/channel/key combination.";
 const EMPTY_SESSION_MESSAGE = "session exists but has no non-system messages.";
 function findDelegatingBridgeId(ctx) {
@@ -187,8 +191,9 @@ exports.baseToolDefinitions = [
             },
         },
         handler: (a) => {
-            const content = fs.readFileSync(a.path, "utf-8");
-            exports.editFileReadTracker.add(a.path);
+            const resolvedPath = resolveLocalToolPath(a.path);
+            const content = fs.readFileSync(resolvedPath, "utf-8");
+            exports.editFileReadTracker.add(resolvedPath);
             const offset = a.offset ? parseInt(a.offset, 10) : undefined;
             const limit = a.limit ? parseInt(a.limit, 10) : undefined;
             if (offset === undefined && limit === undefined)
@@ -213,8 +218,9 @@ exports.baseToolDefinitions = [
             },
         },
         handler: (a) => {
-            fs.mkdirSync(path.dirname(a.path), { recursive: true });
-            fs.writeFileSync(a.path, a.content, "utf-8");
+            const resolvedPath = resolveLocalToolPath(a.path);
+            fs.mkdirSync(path.dirname(resolvedPath), { recursive: true });
+            fs.writeFileSync(resolvedPath, a.content, "utf-8");
             return "ok";
         },
     },
@@ -236,12 +242,13 @@ exports.baseToolDefinitions = [
             },
         },
         handler: (a) => {
-            if (!exports.editFileReadTracker.has(a.path)) {
+            const resolvedPath = resolveLocalToolPath(a.path);
+            if (!exports.editFileReadTracker.has(resolvedPath)) {
                 return `error: you must read the file with read_file before editing it. call read_file on ${a.path} first.`;
             }
             let content;
             try {
-                content = fs.readFileSync(a.path, "utf-8");
+                content = fs.readFileSync(resolvedPath, "utf-8");
             }
             catch (e) {
                 return `error: could not read file: ${e instanceof Error ? e.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(e)}`;
@@ -265,7 +272,7 @@ exports.baseToolDefinitions = [
             // Single unique match -- replace
             const idx = occurrences[0];
             const updated = content.slice(0, idx) + a.new_string + content.slice(idx + a.old_string.length);
-            fs.writeFileSync(a.path, updated, "utf-8");
+            fs.writeFileSync(resolvedPath, updated, "utf-8");
             // Build contextual diff
             const lines = updated.split("\n");
             const prefixLines = content.slice(0, idx).split("\n");
@@ -292,7 +299,7 @@ exports.baseToolDefinitions = [
             },
         },
         handler: (a) => {
-            const cwd = a.cwd || process.cwd();
+            const cwd = a.cwd ? resolveLocalToolPath(a.cwd) : process.cwd();
             const matches = fg.globSync(a.pattern, { cwd, dot: true });
             return matches.sort().join("\n");
         },
@@ -316,7 +323,7 @@ exports.baseToolDefinitions = [
             },
         },
         handler: (a) => {
-            const targetPath = a.path;
+            const targetPath = resolveLocalToolPath(a.path);
             const regex = new RegExp(a.pattern);
             const contextLines = parseInt(a.context_lines || "0", 10);
             const includeGlob = a.include || undefined;

package/dist/senses/bluebubbles-media.js

@@ -39,6 +39,7 @@ const fs = __importStar(require("node:fs/promises"));
 const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
 const runtime_1 = require("../nerves/runtime");
+const identity_1 = require("../heart/identity");
 const MAX_ATTACHMENT_BYTES = 8 * 1024 * 1024;
 const AUDIO_EXTENSIONS = new Set([".mp3", ".wav", ".m4a", ".caf", ".ogg"]);
 const IMAGE_EXTENSIONS = new Set([".jpg", ".jpeg", ".png", ".gif", ".webp", ".heic", ".heif"]);
@@ -65,7 +66,7 @@ const AUDIO_INPUT_FORMAT_BY_EXTENSION = {
 const WHISPER_CPP_FORMULA = "whisper-cpp";
 const WHISPER_CPP_MODEL_NAME = "ggml-base.en.bin";
 const WHISPER_CPP_MODEL_URL = `https://huggingface.co/ggerganov/whisper.cpp/resolve/main/${WHISPER_CPP_MODEL_NAME}`;
-const WHISPER_CPP_TOOLS_DIR = path.join(os.homedir(), ".agentstate", "tools", "whisper-cpp");
+const WHISPER_CPP_TOOLS_DIR = path.join((0, identity_1.getAgentToolsRoot)(), "whisper-cpp");
 const WHISPER_CPP_MODELS_DIR = path.join(WHISPER_CPP_TOOLS_DIR, "models");
 const WHISPER_CPP_MODEL_PATH = path.join(WHISPER_CPP_MODELS_DIR, WHISPER_CPP_MODEL_NAME);
 function buildBlueBubblesApiUrl(baseUrl, endpoint, password) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.58",
+  "version": "0.1.0-alpha.59",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",