doer-agent 0.7.7 → 0.7.9

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-notes-local.js

@@ -0,0 +1,309 @@
+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 resolveSystemTimeZone() {
+    const configured = process.env.TZ?.trim();
+    if (configured) {
+        return configured;
+    }
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+}
+function resolveTimeZoneOffsetString(date, timeZone) {
+    try {
+        const parts = new Intl.DateTimeFormat("en-US", {
+            timeZone,
+            timeZoneName: "shortOffset",
+            hour: "2-digit",
+            minute: "2-digit",
+            hour12: false,
+        }).formatToParts(date);
+        const token = parts.find((part) => part.type === "timeZoneName")?.value || "GMT+0";
+        const matched = token.match(/GMT([+-]\d{1,2})(?::?(\d{2}))?/i);
+        if (!matched) {
+            return "+00:00";
+        }
+        const hourRaw = matched[1] || "+0";
+        const minuteRaw = matched[2] || "00";
+        const sign = hourRaw.startsWith("-") ? "-" : "+";
+        const absHour = String(Math.abs(Number.parseInt(hourRaw, 10))).padStart(2, "0");
+        const absMinute = String(Math.abs(Number.parseInt(minuteRaw, 10))).padStart(2, "0");
+        return `${sign}${absHour}:${absMinute}`;
+    }
+    catch {
+        return "+00:00";
+    }
+}
+function systemTimeParts(date) {
+    const timeZone = resolveSystemTimeZone();
+    const parts = new Intl.DateTimeFormat("en-CA", {
+        timeZone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        hour12: false,
+        hourCycle: "h23",
+    }).formatToParts(date);
+    const pick = (type) => {
+        return parts.find((part) => part.type === type)?.value || "00";
+    };
+    return {
+        year: pick("year"),
+        month: pick("month"),
+        day: pick("day"),
+        hours: pick("hour"),
+        minutes: pick("minute"),
+        seconds: pick("second"),
+        milliseconds: String(date.getMilliseconds()).padStart(3, "0"),
+        offset: resolveTimeZoneOffsetString(date, timeZone),
+    };
+}
+function nowIso() {
+    const parts = systemTimeParts(new Date());
+    return `${parts.year}-${parts.month}-${parts.day}T${parts.hours}:${parts.minutes}:${parts.seconds}.${parts.milliseconds}${parts.offset}`;
+}
+function createTimeBasedPatchId(createdAt) {
+    const stamp = createdAt
+        .replace("T", "t")
+        .replace(/([+-])(\d{2}):?(\d{2})$/, (_match, sign, hours, minutes) => {
+        return `${sign === "-" ? "m" : "p"}${hours}${minutes}`;
+    })
+        .replace(/[-:.]/g, "")
+        .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, month } = systemTimeParts(Number.isNaN(date.getTime()) ? new Date() : date);
+    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()}`;
 }
@@ -168,7 +171,10 @@ export function writeRpcStream(requestId, stream, chunk) {
 }
 function resolveLogTimeZone() {
     const configured = process.env.DOER_AGENT_LOG_TIMEZONE?.trim() || process.env.TZ?.trim();
-    return configured && configured.length > 0 ? configured : "Asia/Seoul";
+    if (configured && configured.length > 0) {
+        return configured;
+    }
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
 }
 function resolveTimeZoneOffsetString(date, timeZone) {
     try {
@@ -207,6 +213,7 @@ export function formatLocalTimestamp(date = new Date()) {
             minute: "2-digit",
             second: "2-digit",
             hour12: false,
+            hourCycle: "h23",
         }).formatToParts(date);
         const pick = (type) => {
             return parts.find((part) => part.type === type)?.value || "00";

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.7",
+  "version": "0.7.9",
   "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.