doer-agent 0.7.6 → 0.7.8

package/dist/agent-bundled-skills.js

@@ -46,8 +46,7 @@ async function removeLegacyManagedSkill(args) {
     }
 }
 export async function ensureBundledDoerSkills(args) {
-    const sourceRootExists = await pathExists(args.bundledSkillsRoot);
-    if (!sourceRootExists) {
+    if (!(await pathExists(args.bundledSkillsRoot))) {
         return;
     }
     const entries = await readdir(args.bundledSkillsRoot, { withFileTypes: true });
@@ -55,8 +54,7 @@ export async function ensureBundledDoerSkills(args) {
         if (!entry.isDirectory() || entry.name.startsWith(".")) {
             continue;
         }
-        const sourceSkillDir = path.join(args.bundledSkillsRoot, entry.name);
-        const sourceSkillFile = path.join(sourceSkillDir, "SKILL.md");
+        const sourceSkillFile = path.join(args.bundledSkillsRoot, entry.name, "SKILL.md");
         const targetSkillDir = path.join(args.codexHome, "skills", entry.name);
         const targetSkillFile = path.join(targetSkillDir, "SKILL.md");
         try {
@@ -65,9 +63,8 @@ export async function ensureBundledDoerSkills(args) {
                 args.onInfo?.(`bundled skill skipped name=${entry.name} reason=user-managed-target`);
                 continue;
             }
-            const managedSource = withManagedMarker(source);
             await mkdir(targetSkillDir, { recursive: true });
-            await writeFile(targetSkillFile, managedSource, "utf8");
+            await writeFile(targetSkillFile, withManagedMarker(source), "utf8");
             await removeLegacyManagedSkill({ codexHome: args.codexHome, skillName: entry.name, onInfo: args.onInfo });
             args.onInfo?.(`bundled skill synced name=${entry.name} path=.codex/skills/${entry.name}/SKILL.md`);
         }

package/dist/agent-http-proxy-rpc.js

@@ -1,12 +1,16 @@
-import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { appendFile, readFile, writeFile, mkdir, unlink } from "node:fs/promises";
 import path from "node:path";
 import { StringCodec } from "nats";
 const proxyRpcCodec = StringCodec();
 const PROXY_ID_PATTERN = /^[a-z0-9][a-z0-9-]{1,30}[a-z0-9]$/;
 const MAX_PROXY_BODY_BYTES = 5 * 1024 * 1024;
+const MAX_PROXY_LOGS = 100;
 function getProxyRegistryPath(workspaceRoot) {
     return path.join(workspaceRoot, ".doer-agent", "http-proxies.json");
 }
+function getProxyLogsPath(workspaceRoot, proxyId) {
+    return path.join(workspaceRoot, ".doer-agent", "http-proxy-logs", `${proxyId}.jsonl`);
+}
 function slugify(value) {
     const slug = value
         .trim()
@@ -91,10 +95,39 @@ function normalizeProxyRecord(value) {
         name: normalizeName(row.name),
         host,
         port,
+        enabled: row.enabled !== false,
         createdAt,
         updatedAt,
     };
 }
+function normalizeProxyLogRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    const row = value;
+    const id = typeof row.id === "string" && row.id.trim() ? row.id.trim() : "";
+    const at = typeof row.at === "string" && row.at.trim() ? row.at.trim() : "";
+    const method = typeof row.method === "string" && row.method.trim() ? row.method.trim().toUpperCase() : "";
+    const requestPath = typeof row.path === "string" && row.path.trim() ? row.path.trim() : "/";
+    const status = typeof row.status === "number" && Number.isInteger(row.status) ? row.status : null;
+    const durationMs = typeof row.durationMs === "number" && Number.isFinite(row.durationMs) ? Math.max(0, Math.round(row.durationMs)) : 0;
+    const requestBytes = typeof row.requestBytes === "number" && Number.isFinite(row.requestBytes) ? Math.max(0, Math.round(row.requestBytes)) : 0;
+    const responseBytes = typeof row.responseBytes === "number" && Number.isFinite(row.responseBytes) ? Math.max(0, Math.round(row.responseBytes)) : 0;
+    if (!id || !at || !method) {
+        return null;
+    }
+    return {
+        id,
+        at,
+        method,
+        path: requestPath,
+        status,
+        durationMs,
+        requestBytes,
+        responseBytes,
+        error: typeof row.error === "string" && row.error.trim() ? row.error.trim().slice(0, 500) : null,
+    };
+}
 async function readProxyRegistry(workspaceRoot) {
     const raw = await readFile(getProxyRegistryPath(workspaceRoot), "utf8").catch(() => "");
     if (!raw) {
@@ -118,6 +151,33 @@ async function writeProxyRegistry(workspaceRoot, proxies) {
     await mkdir(path.dirname(registryPath), { recursive: true });
     await writeFile(registryPath, `${JSON.stringify({ proxies }, null, 2)}\n`, "utf8");
 }
+function normalizeLimit(value, fallback) {
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric)) {
+        return fallback;
+    }
+    return Math.max(1, Math.min(Math.floor(numeric), 1000));
+}
+async function readProxyLogs(workspaceRoot, proxyId, limit) {
+    const raw = await readFile(getProxyLogsPath(workspaceRoot, proxyId), "utf8").catch(() => "");
+    if (!raw) {
+        return [];
+    }
+    return raw
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .slice(-limit)
+        .map((line) => {
+        try {
+            return normalizeProxyLogRecord(JSON.parse(line));
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((log) => Boolean(log));
+}
 async function createProxy(workspaceRoot, request) {
     const proxies = await readProxyRegistry(workspaceRoot);
     const name = normalizeName(request.name);
@@ -136,54 +196,132 @@ async function createProxy(workspaceRoot, request) {
         name,
         host,
         port,
+        enabled: request.enabled !== false,
         createdAt: now,
         updatedAt: now,
     };
     await writeProxyRegistry(workspaceRoot, [...proxies, proxy].sort((a, b) => b.createdAt.localeCompare(a.createdAt)));
     return proxy;
 }
+async function updateProxy(workspaceRoot, request) {
+    const proxyId = normalizeProxyId(request.proxyId);
+    const proxies = await readProxyRegistry(workspaceRoot);
+    const proxy = proxies.find((item) => item.id === proxyId);
+    if (!proxy) {
+        throw new Error("proxy not found");
+    }
+    const updated = {
+        ...proxy,
+        name: request.name === undefined ? proxy.name : normalizeName(request.name),
+        host: request.host === undefined ? proxy.host : normalizeHost(request.host),
+        port: request.port === undefined ? proxy.port : normalizePort(request.port),
+        enabled: request.enabled === undefined ? proxy.enabled : request.enabled !== false,
+        updatedAt: new Date().toISOString(),
+    };
+    await writeProxyRegistry(workspaceRoot, proxies.map((item) => (item.id === proxyId ? updated : item)));
+    return updated;
+}
 async function deleteProxy(workspaceRoot, proxyId) {
     const proxies = await readProxyRegistry(workspaceRoot);
     await writeProxyRegistry(workspaceRoot, proxies.filter((proxy) => proxy.id !== proxyId));
+    await unlink(getProxyLogsPath(workspaceRoot, proxyId)).catch(() => undefined);
 }
-async function handleProxyFetch(workspaceRoot, request) {
+async function appendProxyLog(workspaceRoot, proxyId, log) {
+    const entry = {
+        id: `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`,
+        at: new Date().toISOString(),
+        ...log,
+    };
+    const logsPath = getProxyLogsPath(workspaceRoot, proxyId);
+    await mkdir(path.dirname(logsPath), { recursive: true });
+    await appendFile(logsPath, `${JSON.stringify(entry)}\n`, "utf8");
+}
+async function readProxyLogsForRequest(workspaceRoot, request) {
     const proxyId = normalizeProxyId(request.proxyId);
     const proxy = (await readProxyRegistry(workspaceRoot)).find((item) => item.id === proxyId);
     if (!proxy) {
         throw new Error("proxy not found");
     }
+    return {
+        proxy,
+        events: await readProxyLogs(workspaceRoot, proxyId, normalizeLimit(request.limit, MAX_PROXY_LOGS)),
+    };
+}
+async function handleProxyFetch(workspaceRoot, request) {
+    const proxyId = normalizeProxyId(request.proxyId);
+    const proxy = (await readProxyRegistry(workspaceRoot)).find((item) => item.id === proxyId);
+    const startedAt = Date.now();
     const method = normalizeMethod(request.method);
     const requestPath = normalizePath(request.path);
-    const headers = normalizeHeaders(request.headers);
     const bodyBase64 = typeof request.bodyBase64 === "string" ? request.bodyBase64 : "";
     const body = bodyBase64 ? Buffer.from(bodyBase64, "base64") : undefined;
+    const requestBytes = body?.byteLength ?? 0;
+    let status = null;
+    let responseBytes = 0;
+    let errorMessage = null;
+    const finishLog = async () => {
+        await appendProxyLog(workspaceRoot, proxyId, {
+            method,
+            path: requestPath,
+            status,
+            durationMs: Date.now() - startedAt,
+            requestBytes,
+            responseBytes,
+            error: errorMessage,
+        }).catch(() => undefined);
+    };
+    if (!proxy) {
+        throw new Error("proxy not found");
+    }
+    if (!proxy.enabled) {
+        errorMessage = "proxy disabled";
+        await finishLog();
+        throw new Error("proxy disabled");
+    }
+    const headers = normalizeHeaders(request.headers);
     if ((body?.byteLength ?? 0) > MAX_PROXY_BODY_BYTES) {
+        errorMessage = "proxy request body too large";
+        await finishLog();
         throw new Error("proxy request body too large");
     }
-    const url = new URL(requestPath, `http://${proxy.host}:${proxy.port}`);
-    const response = await fetch(url, {
-        method,
-        headers,
-        body: method === "GET" || method === "HEAD" ? undefined : body,
-        redirect: "manual",
-    });
-    const responseBuffer = Buffer.from(await response.arrayBuffer());
-    if (responseBuffer.byteLength > MAX_PROXY_BODY_BYTES) {
-        throw new Error("proxy response body too large");
+    try {
+        const url = new URL(requestPath, `http://${proxy.host}:${proxy.port}`);
+        const response = await fetch(url, {
+            method,
+            headers,
+            body: method === "GET" || method === "HEAD" ? undefined : body,
+            redirect: "manual",
+        });
+        status = response.status;
+        const responseBuffer = Buffer.from(await response.arrayBuffer());
+        responseBytes = responseBuffer.byteLength;
+        if (responseBuffer.byteLength > MAX_PROXY_BODY_BYTES) {
+            errorMessage = "proxy response body too large";
+            await finishLog();
+            throw new Error("proxy response body too large");
+        }
+        const responseHeaders = {};
+        response.headers.forEach((value, key) => {
+            responseHeaders[key] = value;
+        });
+        await finishLog();
+        return {
+            status: response.status,
+            statusText: response.statusText,
+            headers: responseHeaders,
+            bodyBase64: responseBuffer.toString("base64"),
+        };
+    }
+    catch (error) {
+        if (!errorMessage) {
+            errorMessage = error instanceof Error ? error.message : String(error);
+            await finishLog();
+        }
+        throw error;
     }
-    const responseHeaders = {};
-    response.headers.forEach((value, key) => {
-        responseHeaders[key] = value;
-    });
-    return {
-        status: response.status,
-        statusText: response.statusText,
-        headers: responseHeaders,
-        bodyBase64: responseBuffer.toString("base64"),
-    };
 }
 async function executeProxyRpc(args) {
-    const action = args.request.action === "create" || args.request.action === "delete" || args.request.action === "handle"
+    const action = args.request.action === "create" || args.request.action === "update" || args.request.action === "delete" || args.request.action === "logs" || args.request.action === "handle"
         ? args.request.action
         : "list";
     if (action === "list") {
@@ -192,10 +330,16 @@ async function executeProxyRpc(args) {
     if (action === "create") {
         return { ok: true, action, proxy: await createProxy(args.workspaceRoot, args.request) };
     }
+    if (action === "update") {
+        return { ok: true, action, proxy: await updateProxy(args.workspaceRoot, args.request) };
+    }
     if (action === "delete") {
         await deleteProxy(args.workspaceRoot, normalizeProxyId(args.request.proxyId));
         return { ok: true, action };
     }
+    if (action === "logs") {
+        return { ok: true, action, ...await readProxyLogsForRequest(args.workspaceRoot, args.request) };
+    }
     return { ok: true, action, response: await handleProxyFetch(args.workspaceRoot, args.request) };
 }
 export async function handleHttpProxyRpcMessage(args) {

package/dist/agent-notes-local.js

@@ -0,0 +1,244 @@
+import crypto from "node:crypto";
+import path from "node:path";
+import { mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { formatPatch, structuredPatch } from "diff";
+const AGENT_NOTES_ROOT = ".doer-agent/notes";
+const PATCHES_ROOT = `${AGENT_NOTES_ROOT}/patches`;
+function nowIso() {
+    return new Date().toISOString();
+}
+function createTimeBasedPatchId(createdAt) {
+    const stamp = createdAt.replace(/[-:.]/g, "").replace("T", "t").replace("Z", "z");
+    const random = Math.random().toString(36).slice(2, 8);
+    return `${stamp}-${random}`;
+}
+function patchRelPath(id, createdAt) {
+    const date = new Date(createdAt);
+    const year = String(date.getUTCFullYear());
+    const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+    return path.posix.join(PATCHES_ROOT, year, month, `${id}.patch`);
+}
+export function sanitizeNoteId(value) {
+    const trimmed = typeof value === "string" ? value.trim() : "";
+    const baseName = path.posix.basename(trimmed);
+    const withoutSlashes = baseName.replace(/[\\/]/g, "");
+    if (!withoutSlashes || withoutSlashes === "." || withoutSlashes === "..") {
+        throw new Error("note filename is required");
+    }
+    return withoutSlashes.endsWith(".md") ? withoutSlashes : `${withoutSlashes}.md`;
+}
+function workspacePath(workspaceRoot, relPath) {
+    const root = path.resolve(workspaceRoot);
+    const abs = path.resolve(root, relPath.replace(/^\/+/, ""));
+    if (abs !== root && !abs.startsWith(root + path.sep)) {
+        throw new Error("path escapes workspace root");
+    }
+    return abs;
+}
+function noteRelPath(noteId) {
+    return path.posix.join(AGENT_NOTES_ROOT, sanitizeNoteId(noteId));
+}
+function sha256(text) {
+    return crypto.createHash("sha256").update(text).digest("hex");
+}
+async function readTextIfExists(abs) {
+    try {
+        return await readFile(abs, "utf8");
+    }
+    catch (error) {
+        if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+            return "";
+        }
+        throw error;
+    }
+}
+function metadata(args) {
+    const rows = [
+        `# doer-note-patch-id: ${args.patchId}`,
+        `# created-at: ${args.createdAt}`,
+        `# operation: ${args.operation}`,
+        `# note-id: ${args.noteId}`,
+        `# note-path: ${noteRelPath(args.noteId)}`,
+    ];
+    if (args.nextNoteId) {
+        rows.push(`# next-note-id: ${args.nextNoteId}`);
+        rows.push(`# next-note-path: ${noteRelPath(args.nextNoteId)}`);
+    }
+    if (typeof args.oldText === "string" && typeof args.nextText === "string") {
+        rows.push(`# base-sha256: ${sha256(args.oldText)}`);
+        rows.push(`# next-sha256: ${sha256(args.nextText)}`);
+    }
+    return rows;
+}
+function changedPatch(args) {
+    const patch = structuredPatch(`a/${args.noteId}`, `b/${args.noteId}`, args.oldText, args.nextText, undefined, undefined, { context: 3 });
+    patch.isGit = true;
+    return `${metadata(args).join("\n")}\n${formatPatch(patch)}`;
+}
+function renamePatch(args) {
+    const patch = {
+        oldFileName: `a/${args.oldNoteId}`,
+        newFileName: `b/${args.nextNoteId}`,
+        oldHeader: undefined,
+        newHeader: undefined,
+        hunks: [],
+        isGit: true,
+        isRename: true,
+    };
+    return `${metadata({
+        patchId: args.patchId,
+        createdAt: args.createdAt,
+        operation: "rename",
+        noteId: args.oldNoteId,
+        nextNoteId: args.nextNoteId,
+    }).join("\n")}\n${formatPatch(patch)}`;
+}
+async function writePatch(workspaceRoot, patchId, createdAt, text) {
+    const relPath = patchRelPath(patchId, createdAt);
+    const abs = workspacePath(workspaceRoot, relPath);
+    await mkdir(path.dirname(abs), { recursive: true });
+    await writeFile(abs, text, "utf8");
+    return relPath;
+}
+export async function listAgentNotesLocal(workspaceRoot) {
+    const rootAbs = workspacePath(workspaceRoot, AGENT_NOTES_ROOT);
+    const rows = await readdir(rootAbs, { withFileTypes: true }).catch(() => []);
+    const notes = await Promise.all(rows
+        .filter((row) => row.isFile() && row.name.endsWith(".md"))
+        .map(async (row) => {
+        const abs = path.join(rootAbs, row.name);
+        const entry = await stat(abs);
+        const id = sanitizeNoteId(row.name);
+        return {
+            id,
+            path: noteRelPath(id),
+            name: row.name,
+            size: entry.size,
+            mtimeMs: entry.mtimeMs,
+        };
+    }));
+    notes.sort((a, b) => {
+        return b.mtimeMs - a.mtimeMs || a.name.localeCompare(b.name);
+    });
+    return notes;
+}
+export async function getAgentNoteLocal(workspaceRoot, noteId) {
+    const id = sanitizeNoteId(noteId);
+    const content = await readTextIfExists(workspacePath(workspaceRoot, noteRelPath(id)));
+    return {
+        id,
+        path: noteRelPath(id),
+        name: id,
+        content,
+        totalSize: Buffer.byteLength(content, "utf8"),
+    };
+}
+export async function saveAgentNoteLocal(args) {
+    const noteId = sanitizeNoteId(args.noteId);
+    const noteAbs = workspacePath(args.workspaceRoot, noteRelPath(noteId));
+    const oldText = await readTextIfExists(noteAbs);
+    const nextText = args.content.replace(/\r\n/g, "\n");
+    if (oldText === nextText) {
+        return {
+            note: await getAgentNoteLocal(args.workspaceRoot, noteId),
+            notes: await listAgentNotesLocal(args.workspaceRoot),
+            patchPath: null,
+            patchId: null,
+        };
+    }
+    const createdAt = nowIso();
+    const patchId = createTimeBasedPatchId(createdAt);
+    const patchText = changedPatch({ noteId, oldText, nextText, patchId, createdAt, operation: "content" });
+    const patchPath = await writePatch(args.workspaceRoot, patchId, createdAt, patchText);
+    await mkdir(path.dirname(noteAbs), { recursive: true });
+    await writeFile(noteAbs, nextText, "utf8");
+    return {
+        note: await getAgentNoteLocal(args.workspaceRoot, noteId),
+        notes: await listAgentNotesLocal(args.workspaceRoot),
+        patchPath,
+        patchId,
+    };
+}
+export async function createAgentNoteLocal(workspaceRoot, name) {
+    const createdAt = nowIso();
+    const noteId = sanitizeNoteId(name);
+    const noteAbs = workspacePath(workspaceRoot, noteRelPath(noteId));
+    try {
+        await stat(noteAbs);
+        throw new Error("A note with that filename already exists");
+    }
+    catch (error) {
+        if (!(error && typeof error === "object" && "code" in error && error.code === "ENOENT")) {
+            throw error;
+        }
+    }
+    const patchId = createTimeBasedPatchId(createdAt);
+    const patchText = changedPatch({ noteId, oldText: "", nextText: "", patchId, createdAt, operation: "create" });
+    const patchPath = await writePatch(workspaceRoot, patchId, createdAt, patchText);
+    await mkdir(path.dirname(noteAbs), { recursive: true });
+    await writeFile(noteAbs, "", "utf8");
+    return {
+        note: await getAgentNoteLocal(workspaceRoot, noteId),
+        notes: await listAgentNotesLocal(workspaceRoot),
+        patchPath,
+        patchId,
+    };
+}
+export async function renameAgentNoteLocal(args) {
+    const currentId = sanitizeNoteId(args.noteId);
+    const nextId = sanitizeNoteId(args.name);
+    if (currentId === nextId) {
+        return {
+            note: await getAgentNoteLocal(args.workspaceRoot, currentId),
+            notes: await listAgentNotesLocal(args.workspaceRoot),
+            patchPath: null,
+            patchId: null,
+        };
+    }
+    const nextAbs = workspacePath(args.workspaceRoot, noteRelPath(nextId));
+    try {
+        await stat(nextAbs);
+        throw new Error("A note with that filename already exists");
+    }
+    catch (error) {
+        if (!(error && typeof error === "object" && "code" in error && error.code === "ENOENT")) {
+            throw error;
+        }
+    }
+    const currentAbs = workspacePath(args.workspaceRoot, noteRelPath(currentId));
+    const createdAt = nowIso();
+    const patchId = createTimeBasedPatchId(createdAt);
+    const patchPath = await writePatch(args.workspaceRoot, patchId, createdAt, renamePatch({ oldNoteId: currentId, nextNoteId: nextId, patchId, createdAt }));
+    await mkdir(path.dirname(nextAbs), { recursive: true });
+    await rename(currentAbs, nextAbs);
+    return {
+        note: await getAgentNoteLocal(args.workspaceRoot, nextId),
+        notes: await listAgentNotesLocal(args.workspaceRoot),
+        patchPath,
+        patchId,
+    };
+}
+export async function deleteAgentNoteLocal(args) {
+    const noteId = sanitizeNoteId(args.noteId);
+    const noteAbs = workspacePath(args.workspaceRoot, noteRelPath(noteId));
+    const oldText = await readTextIfExists(noteAbs);
+    const createdAt = nowIso();
+    const patchId = createTimeBasedPatchId(createdAt);
+    const patchPath = await writePatch(args.workspaceRoot, patchId, createdAt, changedPatch({ noteId, oldText, nextText: "", patchId, createdAt, operation: "delete" }));
+    await rm(noteAbs, { force: true });
+    const notes = await listAgentNotesLocal(args.workspaceRoot);
+    return {
+        note: notes[0] ? await getAgentNoteLocal(args.workspaceRoot, notes[0].id) : null,
+        notes,
+        patchPath,
+        patchId,
+    };
+}
+export function agentNotesCapabilitiesLocal() {
+    return {
+        storage: "agent-workspace",
+        notesRoot: AGENT_NOTES_ROOT,
+        patchFormat: "git-diff",
+        patchesRoot: PATCHES_ROOT,
+    };
+}

package/dist/agent-notes-rpc.js

@@ -0,0 +1,106 @@
+import { StringCodec } from "nats";
+import { agentNotesCapabilitiesLocal, createAgentNoteLocal, deleteAgentNoteLocal, getAgentNoteLocal, listAgentNotesLocal, renameAgentNoteLocal, saveAgentNoteLocal, } from "./agent-notes-local.js";
+const notesRpcCodec = StringCodec();
+function parseAction(value) {
+    if (value === "capabilities" ||
+        value === "list" ||
+        value === "get" ||
+        value === "create" ||
+        value === "save" ||
+        value === "rename" ||
+        value === "delete") {
+        return value;
+    }
+    throw new Error("unsupported notes action");
+}
+function stringValue(value) {
+    return typeof value === "string" ? value : "";
+}
+async function executeNotesRpc(workspaceRoot, request) {
+    const action = parseAction(request.action);
+    if (action === "capabilities") {
+        return { ok: true, action, capabilities: agentNotesCapabilitiesLocal() };
+    }
+    if (action === "list") {
+        return { ok: true, action, notes: await listAgentNotesLocal(workspaceRoot) };
+    }
+    if (action === "get") {
+        const notes = await listAgentNotesLocal(workspaceRoot);
+        const noteId = stringValue(request.noteId) || notes[0]?.id || "";
+        return {
+            ok: true,
+            action,
+            note: noteId ? await getAgentNoteLocal(workspaceRoot, noteId) : null,
+            notes,
+            capabilities: agentNotesCapabilitiesLocal(),
+        };
+    }
+    if (action === "create") {
+        const name = stringValue(request.name).trim();
+        if (!name) {
+            throw new Error("name is required");
+        }
+        return {
+            ok: true,
+            action,
+            ...(await createAgentNoteLocal(workspaceRoot, name)),
+            capabilities: agentNotesCapabilitiesLocal(),
+        };
+    }
+    if (action === "save") {
+        return {
+            ok: true,
+            action,
+            ...(await saveAgentNoteLocal({
+                workspaceRoot,
+                noteId: stringValue(request.noteId),
+                content: stringValue(request.content),
+            })),
+            capabilities: agentNotesCapabilitiesLocal(),
+        };
+    }
+    if (action === "rename") {
+        const name = stringValue(request.name).trim();
+        if (!name) {
+            throw new Error("name is required");
+        }
+        return {
+            ok: true,
+            action,
+            ...(await renameAgentNoteLocal({
+                workspaceRoot,
+                noteId: stringValue(request.noteId),
+                name,
+            })),
+            capabilities: agentNotesCapabilitiesLocal(),
+        };
+    }
+    return {
+        ok: true,
+        action,
+        ...(await deleteAgentNoteLocal({
+            workspaceRoot,
+            noteId: stringValue(request.noteId),
+        })),
+        capabilities: agentNotesCapabilitiesLocal(),
+    };
+}
+export async function handleNotesRpcMessage(args) {
+    let payload = {};
+    try {
+        payload = JSON.parse(notesRpcCodec.decode(args.msg.data));
+        if (typeof payload.agentId === "string" && payload.agentId.trim() && payload.agentId !== args.agentId) {
+            throw new Error("agent id mismatch");
+        }
+        args.msg.respond(notesRpcCodec.encode(JSON.stringify(await executeNotesRpc(args.workspaceRoot, payload))));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "unknown error";
+        args.msg.respond(notesRpcCodec.encode(JSON.stringify({
+            ok: false,
+            action: typeof payload.action === "string" ? payload.action : "",
+            error: message,
+        })));
+        args.onError(`notes rpc failed action=${typeof payload.action === "string" ? payload.action : "unknown"} error=${message}`);
+    }
+}

package/dist/agent-runtime-utils.js

@@ -22,6 +22,9 @@ export function buildAgentSkillRpcSubject(userId, agentId) {
 export function buildAgentFsRpcSubject(userId, agentId) {
     return `doer.agent.fs.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
 }
+export function buildAgentNotesRpcSubject(userId, agentId) {
+    return `doer.agent.notes.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
+}
 export function buildAgentDaemonRpcSubject(userId, agentId) {
     return `doer.agent.daemon.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
 }

package/dist/agent.js

@@ -5,6 +5,8 @@ import { StringCodec } from "nats";
 import { buildAgentSettingsEnvPatch, readAgentSettingsConfig, } from "./agent-settings.js";
 import { handleFsRpcMessage } from "./agent-fs-rpc.js";
 import { handleGitRpcMessage } from "./agent-git-rpc.js";
+import { handleNotesRpcMessage } from "./agent-notes-rpc.js";
+import { ensureBundledDoerSkills } from "./agent-bundled-skills.js";
 import { subscribeToCodexAppRpc } from "./agent-codex-app-rpc.js";
 import { createCodexAppServerManager } from "./codex-app-server-manager.js";
 import { subscribeToDaemonRpc } from "./agent-daemon-rpc.js";
@@ -15,7 +17,7 @@ import { subscribeToSkillRpc } from "./agent-skill-rpc.js";
 import { subscribeToMaintenanceRpc } from "./agent-maintenance-rpc.js";
 import { subscribeToHttpProxyRpc } from "./agent-http-proxy-rpc.js";
 import { sendSignalToTaskProcess } from "./agent-task-execution.js";
-import { buildAgentCodexAppEventsSubject, buildAgentCodexAppRpcSubject, buildAgentDaemonRpcSubject, buildAgentFsRpcSubject, buildAgentGitRpcSubject, buildAgentHttpProxyRpcSubject, buildAgentMaintenanceRpcSubject, buildAgentSettingsRpcSubject, buildAgentSkillRpcSubject, formatLocalTimestamp, parseArgs, resolveAgentVersion, resolveArgOrEnv, resolveContainerReachableServerBaseUrl, sanitizeUserId, sleep, } from "./agent-runtime-utils.js";
+import { buildAgentCodexAppEventsSubject, buildAgentCodexAppRpcSubject, buildAgentDaemonRpcSubject, buildAgentFsRpcSubject, buildAgentGitRpcSubject, buildAgentHttpProxyRpcSubject, buildAgentMaintenanceRpcSubject, buildAgentNotesRpcSubject, buildAgentSettingsRpcSubject, buildAgentSkillRpcSubject, formatLocalTimestamp, parseArgs, resolveAgentVersion, resolveArgOrEnv, resolveContainerReachableServerBaseUrl, sanitizeUserId, sleep, } from "./agent-runtime-utils.js";
 import { createRuntimeEnvHelpers } from "./agent-runtime-env.js";
 import { createEventPersistenceHelpers, heartbeatAgentSession, postJson, } from "./agent-runtime-io.js";
 import { handleSettingsRpcMessage } from "./agent-settings-rpc.js";
@@ -23,6 +25,7 @@ const DEFAULT_SERVER_BASE_URL = "https://doer.cranix.net";
 const AGENT_MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
 const AGENT_PROJECT_DIR = path.join(AGENT_MODULE_DIR, "..");
 const AGENT_PACKAGE_JSON_PATH = path.join(AGENT_PROJECT_DIR, "package.json");
+const BUNDLED_SKILLS_ROOT = path.join(AGENT_PROJECT_DIR, "runtime", "skills");
 const HEARTBEAT_INTERVAL_MS = 5_000;
 const HEARTBEAT_FAILURE_THRESHOLD = 3;
 const codexAppEventCodec = StringCodec();
@@ -108,6 +111,25 @@ function subscribeToFsRpc(args) {
     });
     writeAgentInfo(`fs rpc subscribed subject=${subject}`);
 }
+function subscribeToNotesRpc(args) {
+    const subject = buildAgentNotesRpcSubject(args.userId, args.agentId);
+    args.jetstream.nc.subscribe(subject, {
+        callback: (error, msg) => {
+            if (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                writeAgentError(`notes rpc subscription error: ${message}`);
+                return;
+            }
+            void handleNotesRpcMessage({
+                msg,
+                workspaceRoot: resolveWorkspaceRoot(),
+                agentId: args.agentId,
+                onError: writeAgentError,
+            });
+        },
+    });
+    writeAgentInfo(`notes rpc subscribed subject=${subject}`);
+}
 function formatCodexAppNotificationParams(params) {
     if (params === undefined) {
         return "undefined";
@@ -249,6 +271,12 @@ async function main() {
                         jetstream.nc.publish(buildAgentCodexAppEventsSubject(userId, initialAgentId), codexAppEventCodec.encode(JSON.stringify(event)));
                     },
                 });
+                void ensureBundledDoerSkills({
+                    bundledSkillsRoot: BUNDLED_SKILLS_ROOT,
+                    codexHome: runtimeEnvHelpers.resolveCodexHomePath(),
+                    onInfo: writeAgentInfo,
+                    onError: writeAgentError,
+                });
                 subscribeToFsRpc({
                     jetstream,
                     serverBaseUrl,
@@ -256,6 +284,11 @@ async function main() {
                     agentId: initialAgentId,
                     agentToken,
                 });
+                subscribeToNotesRpc({
+                    jetstream,
+                    userId,
+                    agentId: initialAgentId,
+                });
                 subscribeToDaemonRpc({
                     nc: jetstream.nc,
                     subject: buildAgentDaemonRpcSubject(userId, initialAgentId),

package/dist/daemon-mcp-server.js

@@ -1,3 +1,4 @@
+import { spawn } from "node:child_process";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -6,6 +7,7 @@ import * as z from "zod/v4";
 import { deleteAgentDaemonLocal, listAgentDaemonsLocal, readAgentDaemonLogsLocal, restartAgentDaemonLocal, startAgentDaemonLocal, stopAgentDaemonLocal, } from "./agent-daemon-rpc.js";
 import { readAgentSettingsConfig } from "./agent-settings.js";
 import { createRuntimeEnvHelpers } from "./agent-runtime-env.js";
+import { agentNotesCapabilitiesLocal, createAgentNoteLocal, deleteAgentNoteLocal, getAgentNoteLocal, listAgentNotesLocal, renameAgentNoteLocal, saveAgentNoteLocal, } from "./agent-notes-local.js";
 const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
 const AGENT_PROJECT_DIR = path.join(MODULE_DIR, "..");
 function parseWorkspaceRoot(argv) {
@@ -17,6 +19,23 @@ function parseWorkspaceRoot(argv) {
 function formatJson(value) {
     return JSON.stringify(value, null, 2);
 }
+function runSearch(command, args, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk;
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk;
+        });
+        child.once("error", reject);
+        child.once("close", (code) => resolve({ code: code ?? 1, stdout, stderr }));
+    });
+}
 async function main() {
     const workspaceRoot = parseWorkspaceRoot(process.argv.slice(2));
     const runtimeEnvHelpers = createRuntimeEnvHelpers({
@@ -156,6 +175,112 @@ async function main() {
             structuredContent: logs,
         };
     });
+    server.registerTool("notes_list", {
+        description: "List Doer note files in .doer-agent/notes.",
+        inputSchema: {},
+    }, async () => {
+        const notes = await listAgentNotesLocal(workspaceRoot);
+        return {
+            content: [{ type: "text", text: formatJson({ notes, capabilities: agentNotesCapabilitiesLocal() }) }],
+            structuredContent: { notes, capabilities: agentNotesCapabilitiesLocal() },
+        };
+    });
+    server.registerTool("notes_read", {
+        description: "Read a Doer note file from .doer-agent/notes.",
+        inputSchema: {
+            noteId: z.string().optional().describe("Note filename. Defaults to the first note when omitted."),
+        },
+    }, async ({ noteId }) => {
+        const notes = await listAgentNotesLocal(workspaceRoot);
+        const targetNoteId = noteId?.trim() || notes[0]?.id || "";
+        const note = targetNoteId ? await getAgentNoteLocal(workspaceRoot, targetNoteId) : null;
+        return {
+            content: [{ type: "text", text: formatJson({ note, capabilities: agentNotesCapabilitiesLocal() }) }],
+            structuredContent: { note, capabilities: agentNotesCapabilitiesLocal() },
+        };
+    });
+    server.registerTool("notes_create", {
+        description: "Create an empty Doer note and record a patch entry.",
+        inputSchema: {
+            name: z.string().min(1).describe("Note filename. .md is appended if omitted."),
+        },
+    }, async ({ name }) => {
+        const result = await createAgentNoteLocal(workspaceRoot, name);
+        return {
+            content: [{ type: "text", text: formatJson({ ...result, capabilities: agentNotesCapabilitiesLocal() }) }],
+            structuredContent: { ...result, capabilities: agentNotesCapabilitiesLocal() },
+        };
+    });
+    server.registerTool("notes_save", {
+        description: "Save a Doer note and record a git-diff patch entry for the content change.",
+        inputSchema: {
+            noteId: z.string().min(1).describe("Note filename."),
+            content: z.string().describe("Full note content to save."),
+        },
+    }, async ({ noteId, content }) => {
+        const result = await saveAgentNoteLocal({ workspaceRoot, noteId, content });
+        return {
+            content: [{ type: "text", text: formatJson({ ...result, capabilities: agentNotesCapabilitiesLocal() }) }],
+            structuredContent: { ...result, capabilities: agentNotesCapabilitiesLocal() },
+        };
+    });
+    server.registerTool("notes_rename", {
+        description: "Rename a Doer note and record a git-diff rename patch entry.",
+        inputSchema: {
+            noteId: z.string().describe("Current note filename."),
+            name: z.string().min(1).describe("New filename. .md is appended if omitted."),
+        },
+    }, async ({ noteId, name }) => {
+        const result = await renameAgentNoteLocal({ workspaceRoot, noteId, name });
+        return {
+            content: [{ type: "text", text: formatJson({ ...result, capabilities: agentNotesCapabilitiesLocal() }) }],
+            structuredContent: { ...result, capabilities: agentNotesCapabilitiesLocal() },
+        };
+    });
+    server.registerTool("notes_delete", {
+        description: "Delete a Doer note and record a git-diff deletion patch entry.",
+        inputSchema: {
+            noteId: z.string().describe("Note filename to delete."),
+        },
+    }, async ({ noteId }) => {
+        const result = await deleteAgentNoteLocal({ workspaceRoot, noteId });
+        return {
+            content: [{ type: "text", text: formatJson({ ...result, capabilities: agentNotesCapabilitiesLocal() }) }],
+            structuredContent: { ...result, capabilities: agentNotesCapabilitiesLocal() },
+        };
+    });
+    server.registerTool("notes_search", {
+        description: "Search Doer notes with ripgrep under .doer-agent/notes. Patches are excluded by default.",
+        inputSchema: {
+            query: z.string().min(1).describe("Text or regex pattern to search for."),
+            includePatches: z.boolean().optional().describe("Search patch history too."),
+            fixedStrings: z.boolean().optional().describe("Treat query as a literal string."),
+            limit: z.number().int().min(1).max(200).optional().describe("Maximum matching lines to return."),
+        },
+    }, async ({ query, includePatches, fixedStrings, limit }) => {
+        const args = [
+            "--line-number",
+            "--column",
+            "--no-heading",
+            "--color=never",
+            fixedStrings === false ? null : "--fixed-strings",
+            "--glob",
+            "*.md",
+            includePatches ? "--glob" : null,
+            includePatches ? "*.patch" : null,
+            query,
+            ".doer-agent/notes",
+        ].filter((item) => Boolean(item));
+        const result = await runSearch("rg", args, workspaceRoot);
+        if (result.code !== 0 && result.code !== 1) {
+            throw new Error(result.stderr || "notes search failed");
+        }
+        const lines = result.stdout.split("\n").filter(Boolean).slice(0, limit ?? 50);
+        return {
+            content: [{ type: "text", text: formatJson({ matches: lines, truncated: result.stdout.split("\n").filter(Boolean).length > lines.length }) }],
+            structuredContent: { matches: lines, truncated: result.stdout.split("\n").filter(Boolean).length > lines.length },
+        };
+    });
     const transport = new StdioServerTransport();
     await server.connect(transport);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doer-agent",
-  "version": "0.7.6",
+  "version": "0.7.8",
   "description": "Reverse-polling agent runtime for doer",
   "type": "module",
   "main": "dist/agent.js",
@@ -27,6 +27,7 @@
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@openai/codex": "^0.133.0",
     "@openai/codex-sdk": "^0.133.0",
+    "diff": "^9.0.0",
     "nats": "^2.29.3",
     "tar": "^7.5.15"
   },

package/runtime/skills/doer-agent-notes/SKILL.md

@@ -0,0 +1,73 @@
+---
+name: doer-agent-notes
+description: Use when working with Doer agent text notes, memo files, note patch history, or note CRUD/search tools.
+---
+
+# Doer Agent Notes
+
+Use the Doer notes tools for note CRUD whenever they are available. Do not edit `.doer-agent/notes/*.md` directly when a notes tool can perform the same operation, because note tools also record patch history.
+
+## Storage
+
+Current note files live directly under `.doer-agent/notes` as Markdown files.
+
+- Notes: `.doer-agent/notes/{note-id}.md`
+- There is no built-in default note filename. Users choose the filename when creating a note.
+- `note-id` is the filename. If the extension is omitted, normalize it back to `.md`.
+- Note content is free-form Markdown text.
+- Titles, tags, and frontmatter are optional; do not require them for storage.
+
+## Tools
+
+Prefer these tools when present:
+
+- `notes_list`
+- `notes_read`
+- `notes_create`
+- `notes_save`
+- `notes_rename`
+- `notes_delete`
+- `notes_search`
+
+## Patch History
+
+Note change history is append-only and stored under `.doer-agent/notes/patches/YYYY/MM/*.patch`.
+
+Patch files use git diff format with Doer metadata comment lines before the diff body.
+
+For content changes, include:
+
+- `# doer-note-patch-id`
+- `# created-at`
+- `# operation: content`
+- `# note-id`
+- `# note-path`
+- `# base-sha256`
+- `# next-sha256`
+
+For filename changes, include:
+
+- `# doer-note-patch-id`
+- `# created-at`
+- `# operation: rename`
+- `# note-id`
+- `# note-path`
+- `# next-note-id`
+- `# next-note-path`
+
+For deletions, include:
+
+- `# doer-note-patch-id`
+- `# created-at`
+- `# operation: delete`
+- `# note-id`
+- `# note-path`
+- `# base-sha256`
+- `# next-sha256`
+
+## Principles
+
+- The note source of truth is human-readable `.md` files.
+- Change history is append-only `.patch` files.
+- Search indexes, vector databases, and other derived stores are not source of truth.
+- Derived data must be reproducible from `.md` and `.patch` files.