@biaoo/tiangong-wiki 0.2.2 → 0.3.0

package/dist/daemon/server.js

@@ -2,13 +2,20 @@ import http from "node:http";
 import { readFileSync } from "node:fs";
 import path from "node:path";
 import { getMeta } from "../core/db.js";
-import { openRuntimeDb } from "../core/runtime.js";
+import { normalizePageId } from "../core/paths.js";
+import { readCanonicalPageSourceById } from "../core/page-source.js";
+import { selectPageById } from "../core/query.js";
+import { loadRuntimeConfig, openRuntimeDb } from "../core/runtime.js";
+import { DaemonWriteQueue } from "./write-queue.js";
+import { appendAuditEvent } from "./audit-log.js";
+import { commitWriteJournal, GitPushScheduler } from "./git-journal.js";
+import { buildCliWriteActor, buildSystemWriteActor, resolveWriteActor } from "./write-actor.js";
 import { exportGraphContent, exportIndexContent } from "../operations/export.js";
 import { getDashboardGraphOverview, getDashboardLintSummary, getDashboardPageDetail, getDashboardPageSource, getDashboardQueueItemDetail, getDashboardQueueSummary, getDashboardStatus, getDashboardVaultFileDetail, getDashboardVaultSummary, listDashboardLintIssues, listDashboardQueueItems, listDashboardVaultFiles, openDashboardPageSource, openDashboardVaultFile, retryDashboardQueueItem, searchDashboardGraph, } from "../operations/dashboard.js";
 import { diffVaultFiles, findPages, ftsSearchPages, getPageInfo, getVaultQueue, getWikiStat, listPages, listVaultFiles, renderLintResult, runLint, searchPages, traverseGraph, } from "../operations/query.js";
 import { createTemplate, listTemplates, listTypes, recommendTypes, showTemplate, showType, } from "../operations/type-template.js";
 import { runTemplateLint } from "../operations/template-lint.js";
-import { createPage, runSync, runSyncCommand } from "../operations/write.js";
+import { createPage, runSync, runSyncCommand, updatePage } from "../operations/write.js";
 import { AppError, asAppError } from "../utils/errors.js";
 import { pathExistsSync } from "../utils/fs.js";
 import { addSeconds, toOffsetIso } from "../utils/time.js";
@@ -114,11 +121,19 @@ async function readJsonBody(request) {
         throw new AppError(`Failed to parse daemon request body: ${error instanceof Error ? error.message : String(error)}`, "config");
     }
 }
-function isBusyError(error) {
-    return (typeof error.details === "object" &&
-        error.details !== null &&
-        "code" in error.details &&
-        error.details.code === "busy");
+function getErrorDetailsCode(error) {
+    if (typeof error.details !== "object" || error.details === null || !("code" in error.details)) {
+        return null;
+    }
+    const code = error.details.code;
+    return typeof code === "string" ? code : null;
+}
+function isConflictError(error) {
+    const code = getErrorDetailsCode(error);
+    return code === "busy" || code === "revision_conflict";
+}
+function isServiceUnavailableError(error) {
+    return getErrorDetailsCode(error) === "queue_full";
 }
 async function buildStatusPayload(env, state) {
     let lastSyncAt = null;
@@ -156,7 +171,6 @@ export async function runDaemonServer(options) {
     let cycleTimer = null;
     let queuedCycle = false;
     let stopping = false;
-    let currentWrite = null;
     let server;
     let resolveClosed = null;
     let nextDashboardLogId = 1;
@@ -200,6 +214,7 @@ export async function runDaemonServer(options) {
         broadcastDashboardLog(entry);
         console.error(entry.line);
     };
+    const gitPushScheduler = new GitPushScheduler(paths, logInfo, env);
     const serveDashboardApp = (requestPath, response) => {
         if (!pathExistsSync(dashboardDistPath)) {
             throw new AppError(`Dashboard assets not found at ${dashboardDistPath}. Build the dashboard bundle before opening /dashboard.`, "not_found");
@@ -273,6 +288,44 @@ export async function runDaemonServer(options) {
             writeDaemonState(paths.daemonStatePath, state);
         }
     };
+    const afterWriteComplete = (task) => {
+        if (queuedCycle && !stopping) {
+            queuedCycle = false;
+            void enqueueWriteTask("cycle", () => runCycleTransaction(buildSystemWriteActor("daemon"), "cycle"), {
+                summarizeResult: summarizeCycleResult,
+            }).catch((error) => {
+                const appError = asAppError(error);
+                logError(`queued cycle failed: ${appError.message}`);
+            });
+            return;
+        }
+        if (task === "cycle" || task === "sync-trigger") {
+            scheduleNextCycle();
+        }
+        else {
+            persistState();
+        }
+    };
+    const writeQueue = new DaemonWriteQueue(env, {
+        onJobStart: (job) => {
+            if (state) {
+                state.currentTask = job.taskType;
+                if (job.taskType === "cycle" || job.taskType === "sync-trigger") {
+                    state.nextRunAt = null;
+                }
+                persistState();
+            }
+        },
+        onJobFinish: (job) => {
+            if (state) {
+                state.lastRunAt = toOffsetIso();
+                state.lastResult = job.status === "succeeded" ? "ok" : "error";
+                state.lastError = job.errorMessage;
+                state.currentTask = "idle";
+            }
+            afterWriteComplete(job.taskType);
+        },
+    });
     const clearTimer = () => {
         if (cycleTimer) {
             clearTimeout(cycleTimer);
@@ -296,7 +349,7 @@ export async function runDaemonServer(options) {
             if (stopping) {
                 return;
             }
-            if (currentWrite) {
+            if (writeQueue.hasWork()) {
                 queuedCycle = true;
                 if (state) {
                     state.nextRunAt = null;
@@ -304,113 +357,305 @@ export async function runDaemonServer(options) {
                 }
                 return;
             }
-            void runDefaultCycle("cycle").catch((error) => {
+            void enqueueWriteTask("cycle", () => runCycleTransaction(buildSystemWriteActor("daemon"), "cycle"), {
+                summarizeResult: summarizeCycleResult,
+            }).catch((error) => {
                 const appError = asAppError(error);
                 logError(`scheduled cycle failed: ${appError.message}`);
             });
         }, interval * 1000);
     };
-    const afterWriteComplete = (task) => {
-        if (queuedCycle && !stopping) {
-            queuedCycle = false;
-            void runDefaultCycle("cycle").catch((error) => {
-                const appError = asAppError(error);
-                logError(`queued cycle failed: ${appError.message}`);
-            });
-            return;
+    const enqueueWriteTask = async (task, run, options = {}) => {
+        if (stopping) {
+            throw new AppError("Wiki daemon is shutting down.", "runtime");
         }
-        if (task === "cycle" || task === "sync-trigger") {
-            scheduleNextCycle();
+        return writeQueue.enqueue(task, run, options);
+    };
+    const enrichWriteResult = (result, actor, git) => {
+        return {
+            ...result,
+            writeMeta: {
+                requestId: actor.requestId,
+                actorId: actor.actorId,
+                actorType: actor.actorType,
+                auditLogPath: paths.auditLogPath,
+                git,
+            },
+        };
+    };
+    const resolveCanonicalPageId = (inputPageId) => {
+        const { db, config } = openRuntimeDb(env);
+        try {
+            const normalizedPageId = normalizePageId(inputPageId, paths.wikiPath);
+            const page = selectPageById(db, config, normalizedPageId);
+            if (!page) {
+                throw new AppError(`Page not found: ${normalizedPageId}`, "not_found");
+            }
+            return String(page.id);
         }
-        else {
-            persistState();
+        finally {
+            db.close();
         }
     };
-    const runWriteTask = async (task, run) => {
-        if (stopping) {
-            throw new AppError("Wiki daemon is shutting down.", "runtime");
+    const readPageRevision = (pageId) => {
+        return readCanonicalPageSourceById(pageId, paths.wikiPath, loadRuntimeConfig(env).config).revision;
+    };
+    const buildErrorDetails = (error) => {
+        const details = typeof error.details === "object" && error.details !== null && !Array.isArray(error.details)
+            ? { ...error.details }
+            : {};
+        if (!("message" in details)) {
+            details.message = error.message;
+        }
+        return details;
+    };
+    const recordSyncFailureAndThrow = (actor, input) => {
+        appendAuditEvent(paths, actor, {
+            operation: input.operation,
+            resourceId: input.resourceId,
+            status: "sync_failed",
+            revisionBefore: input.revisionBefore,
+            revisionAfter: input.revisionAfter,
+            commitHash: null,
+            details: buildErrorDetails(input.error),
+        });
+        throw new AppError(input.error.message, input.error.type, {
+            ...buildErrorDetails(input.error),
+            requestId: actor.requestId,
+            actorId: actor.actorId,
+            actorType: actor.actorType,
+            auditLogPath: paths.auditLogPath,
+        });
+    };
+    const finalizeJournaledWrite = async (actor, input) => {
+        appendAuditEvent(paths, actor, {
+            operation: input.operation,
+            resourceId: input.resourceId,
+            status: "write_applied",
+            revisionBefore: input.revisionBefore,
+            revisionAfter: input.revisionAfter,
+            commitHash: null,
+            details: input.details ?? null,
+        });
+        try {
+            const gitResult = commitWriteJournal(paths, actor, {
+                operation: input.operation,
+                resourceId: input.resourceId,
+            });
+            const pushScheduled = gitResult.status === "committed" ? gitPushScheduler.schedule(actor) : false;
+            appendAuditEvent(paths, actor, {
+                operation: input.operation,
+                resourceId: input.resourceId,
+                status: gitResult.status === "committed" ? "git_commit_succeeded" : "git_commit_skipped",
+                revisionBefore: input.revisionBefore,
+                revisionAfter: input.revisionAfter,
+                commitHash: gitResult.commitHash,
+                details: gitResult.status === "committed" ? { pushScheduled } : { reason: "no_staged_changes" },
+            });
+            return enrichWriteResult(input.result, actor, {
+                status: gitResult.status,
+                commitHash: gitResult.commitHash,
+                pushScheduled,
+            });
         }
-        if (currentWrite) {
-            throw new AppError(`Wiki daemon is busy running ${state?.currentTask ?? "another task"}.`, "runtime", {
-                code: "busy",
-                currentTask: state?.currentTask ?? "unknown",
+        catch (error) {
+            const appError = asAppError(error);
+            appendAuditEvent(paths, actor, {
+                operation: input.operation,
+                resourceId: input.resourceId,
+                status: "git_commit_failed",
+                revisionBefore: input.revisionBefore,
+                revisionAfter: input.revisionAfter,
+                commitHash: null,
+                details: buildErrorDetails(appError),
+            });
+            throw new AppError("Git commit failed after write succeeded.", "runtime", {
+                code: "git_commit_failed",
+                degraded: true,
+                requestId: actor.requestId,
+                actorId: actor.actorId,
+                actorType: actor.actorType,
+                resourceId: input.resourceId,
+                revisionBefore: input.revisionBefore,
+                revisionAfter: input.revisionAfter,
+                auditLogPath: paths.auditLogPath,
+                writeResult: input.result,
+                gitError: appError.message,
             });
         }
-        const promise = (async () => {
-            if (state) {
-                state.currentTask = task;
-                if (task === "cycle" || task === "sync-trigger") {
-                    state.nextRunAt = null;
-                }
-                persistState();
-            }
-            try {
-                const result = await run();
-                if (state) {
-                    state.lastRunAt = toOffsetIso();
-                    state.lastResult = "ok";
-                    state.lastError = null;
-                    state.currentTask = "idle";
-                }
-                return result;
+    };
+    const summarizeCycleResult = (result) => ({
+        status: result.status,
+        task: result.task,
+        sync: {
+            mode: result.sync.mode,
+            inserted: result.sync.inserted,
+            updated: result.sync.updated,
+            deleted: result.sync.deleted,
+            vaultChanges: result.sync.vault.changes,
+        },
+        queue: result.queue,
+    });
+    const runCycleTask = async (task) => {
+        logInfo(`${task}: start`);
+        const syncResult = await runSync(env);
+        logInfo(`${task}: sync ok mode=${syncResult.mode} inserted=${syncResult.inserted} updated=${syncResult.updated} deleted=${syncResult.deleted} vaultChanges=${syncResult.vault.changes}`);
+        const queueResult = {
+            enabled: false,
+            processed: 0,
+            done: 0,
+            skipped: 0,
+            errored: 0,
+            batches: 0,
+        };
+        while (!stopping) {
+            const batchResult = await processVaultQueueBatch(env, {
+                log: (message) => logInfo(`queue ${message}`),
+            });
+            if (!batchResult.enabled) {
+                break;
             }
-            catch (error) {
-                const appError = asAppError(error);
-                if (state) {
-                    state.lastRunAt = toOffsetIso();
-                    state.lastResult = "error";
-                    state.lastError = appError.message;
-                    state.currentTask = "idle";
-                }
-                throw appError;
+            queueResult.enabled = true;
+            if (batchResult.processed === 0) {
+                break;
             }
-            finally {
-                currentWrite = null;
-                afterWriteComplete(task);
+            queueResult.processed += batchResult.processed;
+            queueResult.done += batchResult.done;
+            queueResult.skipped += batchResult.skipped;
+            queueResult.errored += batchResult.errored;
+            queueResult.batches += 1;
+        }
+        if (queueResult.enabled) {
+            logInfo(`${task}: queue summary processed=${queueResult.processed} done=${queueResult.done} skipped=${queueResult.skipped} errored=${queueResult.errored} batches=${queueResult.batches}`);
+        }
+        return {
+            status: "started",
+            task,
+            sync: syncResult,
+            queue: queueResult,
+        };
+    };
+    const runCreateTransaction = async (actor, input) => {
+        try {
+            const result = await createPage(env, input);
+            const revisionAfter = readPageRevision(result.created);
+            return await finalizeJournaledWrite(actor, {
+                operation: "create",
+                resourceId: result.created,
+                revisionBefore: null,
+                revisionAfter,
+                result,
+            });
+        }
+        catch (error) {
+            const appError = asAppError(error);
+            if (getErrorDetailsCode(appError) === "sync_failed") {
+                const details = buildErrorDetails(appError);
+                recordSyncFailureAndThrow(actor, {
+                    operation: "create",
+                    resourceId: typeof details.pageId === "string" ? details.pageId : null,
+                    revisionBefore: null,
+                    revisionAfter: typeof details.revisionAfter === "string" ? details.revisionAfter : null,
+                    error: appError,
+                });
             }
-        })();
-        currentWrite = promise;
-        return promise;
+            throw appError;
+        }
     };
-    const runDefaultCycle = async (task) => {
-        return runWriteTask(task, async () => {
-            logInfo(`${task}: start`);
-            const syncResult = await runSync(env);
-            logInfo(`${task}: sync ok mode=${syncResult.mode} inserted=${syncResult.inserted} updated=${syncResult.updated} deleted=${syncResult.deleted} vaultChanges=${syncResult.vault.changes}`);
-            const queueResult = {
-                enabled: false,
-                processed: 0,
-                done: 0,
-                skipped: 0,
-                errored: 0,
-                batches: 0,
-            };
-            while (!stopping) {
-                const batchResult = await processVaultQueueBatch(env, {
-                    log: (message) => logInfo(`queue ${message}`),
+    const runUpdateTransaction = async (actor, input) => {
+        const canonicalPageId = resolveCanonicalPageId(input.pageId);
+        const revisionBefore = readPageRevision(canonicalPageId);
+        try {
+            const result = await updatePage(env, input);
+            return await finalizeJournaledWrite(actor, {
+                operation: "update",
+                resourceId: result.pageId,
+                revisionBefore,
+                revisionAfter: result.revision,
+                result,
+            });
+        }
+        catch (error) {
+            const appError = asAppError(error);
+            if (getErrorDetailsCode(appError) === "sync_failed") {
+                const details = buildErrorDetails(appError);
+                recordSyncFailureAndThrow(actor, {
+                    operation: "update",
+                    resourceId: typeof details.pageId === "string" ? details.pageId : canonicalPageId,
+                    revisionBefore: typeof details.revisionBefore === "string" ? details.revisionBefore : revisionBefore,
+                    revisionAfter: typeof details.revisionAfter === "string" ? details.revisionAfter : null,
+                    error: appError,
                 });
-                if (!batchResult.enabled) {
-                    break;
-                }
-                queueResult.enabled = true;
-                if (batchResult.processed === 0) {
-                    break;
-                }
-                queueResult.processed += batchResult.processed;
-                queueResult.done += batchResult.done;
-                queueResult.skipped += batchResult.skipped;
-                queueResult.errored += batchResult.errored;
-                queueResult.batches += 1;
-            }
-            if (queueResult.enabled) {
-                logInfo(`${task}: queue summary processed=${queueResult.processed} done=${queueResult.done} skipped=${queueResult.skipped} errored=${queueResult.errored} batches=${queueResult.batches}`);
-            }
-            return {
-                status: "started",
-                task,
-                sync: syncResult,
-                queue: queueResult,
-            };
+            }
+            throw appError;
+        }
+    };
+    const runSyncTransaction = async (actor, input) => {
+        try {
+            const result = await runSyncCommand(env, input);
+            const resourceId = input.targetPaths?.[0] ?? input.vaultFileId ?? "*";
+            return await finalizeJournaledWrite(actor, {
+                operation: "sync",
+                resourceId,
+                revisionBefore: null,
+                revisionAfter: null,
+                result,
+            });
+        }
+        catch (error) {
+            const appError = asAppError(error);
+            return recordSyncFailureAndThrow(actor, {
+                operation: "sync",
+                resourceId: input.targetPaths?.[0] ?? input.vaultFileId ?? "*",
+                revisionBefore: null,
+                revisionAfter: null,
+                error: appError,
+            });
+        }
+    };
+    const runCycleTransaction = async (actor, task) => {
+        try {
+            const result = await runCycleTask(task);
+            return await finalizeJournaledWrite(actor, {
+                operation: task,
+                resourceId: "*",
+                revisionBefore: null,
+                revisionAfter: null,
+                result,
+            });
+        }
+        catch (error) {
+            const appError = asAppError(error);
+            return recordSyncFailureAndThrow(actor, {
+                operation: task,
+                resourceId: "*",
+                revisionBefore: null,
+                revisionAfter: null,
+                error: appError,
+            });
+        }
+    };
+    const runTemplateCreateTransaction = async (actor, input) => {
+        const result = Promise.resolve(createTemplate(env, {
+            type: input.type,
+            title: input.title,
+        }));
+        return await finalizeJournaledWrite(actor, {
+            operation: "template-create",
+            resourceId: `template:${input.type}`,
+            revisionBefore: null,
+            revisionAfter: null,
+            result: await result,
+        });
+    };
+    const runQueueRetryTransaction = async (actor, fileId) => {
+        const result = await retryDashboardQueueItem(env, fileId);
+        return await finalizeJournaledWrite(actor, {
+            operation: "queue-retry",
+            resourceId: `queue:${fileId}`,
+            revisionBefore: null,
+            revisionAfter: null,
+            result,
         });
     };
     const beginShutdown = async () => {
@@ -425,7 +670,7 @@ export async function runDaemonServer(options) {
             persistState();
         }
         try {
-            await currentWrite?.catch(() => undefined);
+            await writeQueue.waitForIdle();
         }
         finally {
             await new Promise((resolve) => {
@@ -464,36 +709,51 @@ export async function runDaemonServer(options) {
             }
             if (method === "POST" && pathname === "/sync") {
                 const body = await readJsonBody(request);
+                const actor = resolveWriteActor(request, body, buildCliWriteActor(env));
                 const pathValue = typeof body.path === "string" && body.path.trim()
                     ? body.path.trim()
                     : Array.isArray(body.targetPaths) && typeof body.targetPaths[0] === "string"
                         ? String(body.targetPaths[0])
                         : undefined;
-                const result = await runWriteTask("sync", async () => runSyncCommand(env, {
+                const result = await enqueueWriteTask("sync", async () => runSyncTransaction(actor, {
                     targetPaths: pathValue ? [pathValue] : undefined,
                     force: body.force === true,
                     skipEmbedding: body.skipEmbedding === true,
                     process: body.process === true,
                     vaultFileId: typeof body.vaultFileId === "string" && body.vaultFileId.trim() ? body.vaultFileId.trim() : undefined,
-                }));
+                }), {
+                    summarizeResult: (payload) => ({
+                        mode: payload.mode,
+                        inserted: payload.inserted,
+                        updated: payload.updated,
+                        deleted: payload.deleted,
+                        queueProcessed: payload.queueProcess?.processed ?? 0,
+                    }),
+                });
                 writeJsonResponse(response, 200, result);
                 return;
             }
             if (method === "POST" && pathname === "/sync/trigger") {
-                if (currentWrite) {
-                    throw new AppError(`Wiki daemon is busy running ${state?.currentTask ?? "another task"}.`, "runtime", {
-                        code: "busy",
-                        currentTask: state?.currentTask ?? "unknown",
-                    });
-                }
-                void runDefaultCycle("sync-trigger").catch((error) => {
-                    const appError = asAppError(error);
-                    logError(`sync-trigger failed: ${appError.message}`);
-                });
-                writeJsonResponse(response, 200, {
-                    status: "started",
-                    currentTask: "sync-trigger",
+                const body = await readJsonBody(request);
+                const actor = resolveWriteActor(request, body, buildCliWriteActor(env));
+                const result = await enqueueWriteTask("sync-trigger", () => runCycleTransaction(actor, "sync-trigger"), {
+                    summarizeResult: summarizeCycleResult,
                 });
+                writeJsonResponse(response, 200, result);
+                return;
+            }
+            if (method === "GET" && pathname === "/write-queue/summary") {
+                writeJsonResponse(response, 200, writeQueue.getSummary());
+                return;
+            }
+            const writeQueueJobMatch = pathname.match(/^\/write-queue\/jobs\/(.+)$/);
+            if (method === "GET" && writeQueueJobMatch) {
+                const jobId = decodePathParam(writeQueueJobMatch[1]);
+                const job = writeQueue.getJob(jobId);
+                if (!job) {
+                    throw new AppError(`Write queue job not found: ${jobId}`, "not_found");
+                }
+                writeJsonResponse(response, 200, job);
                 return;
             }
             if (method === "GET" && pathname === "/api/dashboard/status") {
@@ -535,7 +795,14 @@ export async function runDaemonServer(options) {
             const queueRetryMatch = pathname.match(/^\/api\/dashboard\/queue\/items\/(.+)\/retry$/);
             if (method === "POST" && queueRetryMatch) {
                 const fileId = decodePathParam(queueRetryMatch[1]);
-                writeJsonResponse(response, 200, await runWriteTask("queue-retry", async () => retryDashboardQueueItem(env, fileId)));
+                const body = await readJsonBody(request);
+                const actor = resolveWriteActor(request, body, buildCliWriteActor(env));
+                writeJsonResponse(response, 200, await enqueueWriteTask("queue-retry", async () => runQueueRetryTransaction(actor, fileId), {
+                    summarizeResult: (payload) => ({
+                        fileId,
+                        status: typeof payload.status === "string" ? payload.status : "unknown",
+                    }),
+                }));
                 return;
             }
             const queueItemMatch = pathname.match(/^\/api\/dashboard\/queue\/items\/(.+)$/);
@@ -642,6 +909,28 @@ export async function runDaemonServer(options) {
                 writeJsonResponse(response, 200, getPageInfo(env, pageId));
                 return;
             }
+            if (method === "GET" && pathname === "/page-read") {
+                const pageId = url.searchParams.get("pageId");
+                if (!pageId) {
+                    throw new AppError("pageId is required", "config", {
+                        code: "invalid_request",
+                        field: "pageId",
+                    });
+                }
+                const { db, config, paths } = openRuntimeDb(env);
+                try {
+                    const normalizedPageId = normalizePageId(pageId, paths.wikiPath);
+                    const page = selectPageById(db, config, normalizedPageId);
+                    if (!page) {
+                        throw new AppError(`Page not found: ${normalizedPageId}`, "not_found");
+                    }
+                    writeJsonResponse(response, 200, readCanonicalPageSourceById(String(page.id), paths.wikiPath, config));
+                }
+                finally {
+                    db.close();
+                }
+                return;
+            }
             if (method === "GET" && pathname === "/list") {
                 writeJsonResponse(response, 200, listPages(env, {
                     type: url.searchParams.get("type") ?? undefined,
@@ -676,14 +965,37 @@ export async function runDaemonServer(options) {
             }
             if (method === "POST" && pathname === "/create") {
                 const body = await readJsonBody(request);
+                const actor = resolveWriteActor(request, body, buildCliWriteActor(env));
                 const type = typeof body.type === "string" ? body.type : "";
                 const title = typeof body.title === "string" ? body.title : "";
                 const nodeId = typeof body.nodeId === "string" ? body.nodeId : undefined;
-                const result = await runWriteTask("create", () => createPage(env, {
+                const result = await enqueueWriteTask("create", () => runCreateTransaction(actor, {
                     type,
                     title,
                     nodeId,
-                }));
+                }), {
+                    summarizeResult: (payload) => ({
+                        created: payload.created,
+                        filePath: payload.filePath,
+                    }),
+                });
+                writeJsonResponse(response, 200, result);
+                return;
+            }
+            if (method === "POST" && pathname === "/page-update") {
+                const body = await readJsonBody(request);
+                const actor = resolveWriteActor(request, body, buildCliWriteActor(env));
+                const result = await enqueueWriteTask("update", () => runUpdateTransaction(actor, {
+                    pageId: typeof body.pageId === "string" ? body.pageId : "",
+                    bodyMarkdown: typeof body.bodyMarkdown === "string" ? body.bodyMarkdown : undefined,
+                    frontmatterPatch: body.frontmatterPatch,
+                    ifRevision: typeof body.ifRevision === "string" ? body.ifRevision : undefined,
+                }), {
+                    summarizeResult: (payload) => ({
+                        pageId: payload.pageId,
+                        revision: payload.revision,
+                    }),
+                });
                 writeJsonResponse(response, 200, result);
                 return;
             }
@@ -736,10 +1048,16 @@ export async function runDaemonServer(options) {
             }
             if (method === "POST" && pathname === "/template/create") {
                 const body = await readJsonBody(request);
-                const result = await runWriteTask("template-create", () => Promise.resolve(createTemplate(env, {
+                const actor = resolveWriteActor(request, body, buildCliWriteActor(env));
+                const result = await enqueueWriteTask("template-create", () => runTemplateCreateTransaction(actor, {
                     type: typeof body.type === "string" ? body.type : "",
                     title: typeof body.title === "string" ? body.title : "",
-                })));
+                }), {
+                    summarizeResult: (payload) => ({
+                        pageType: typeof payload.pageType === "string" ? payload.pageType : String(body.type ?? ""),
+                        templatePath: typeof payload.templatePath === "string" ? payload.templatePath : null,
+                    }),
+                });
                 writeJsonResponse(response, 200, result);
                 return;
             }
@@ -766,9 +1084,11 @@ export async function runDaemonServer(options) {
                 ? 400
                 : appError.type === "not_found"
                     ? 404
-                    : isBusyError(appError)
-                        ? 409
-                        : 500;
+                    : isServiceUnavailableError(appError)
+                        ? 503
+                        : isConflictError(appError)
+                            ? 409
+                            : 500;
             writeJsonResponse(response, statusCode, {
                 error: appError.message,
                 type: appError.type,
@@ -801,7 +1121,9 @@ export async function runDaemonServer(options) {
     process.on("SIGTERM", signalHandler);
     process.on("SIGINT", signalHandler);
     if (interval > 0) {
-        void runDefaultCycle("cycle").catch((error) => {
+        void enqueueWriteTask("cycle", () => runCycleTransaction(buildSystemWriteActor("daemon"), "cycle"), {
+            summarizeResult: summarizeCycleResult,
+        }).catch((error) => {
             const appError = asAppError(error);
             logError(`initial cycle failed: ${appError.message}`);
         });