@timqi/pier 0.0.19 → 0.0.21

package/dist/agent/config-sync.js

@@ -0,0 +1,123 @@
+// Credential-blind projection of the portable agent configuration.
+const MODEL_KEYS = ["id", "name", "reasoning", "input", "cost", "contextWindow", "maxTokens", "api"];
+const COST_KEYS = ["input", "output", "cacheRead", "cacheWrite"];
+function record(value, where) {
+    if (!value || typeof value !== "object" || Array.isArray(value) ||
+        ![Object.prototype, null].includes(Object.getPrototypeOf(value))) {
+        throw new Error(`${where} must be an object`);
+    }
+    return value;
+}
+function only(value, keys, where) {
+    if (Object.keys(value).some((key) => !keys.includes(key))) {
+        throw new Error(`${where} contains unsupported fields`);
+    }
+}
+function modelDefinition(value) {
+    const model = record(value, "model");
+    only(model, MODEL_KEYS, "model");
+    if (typeof model.id !== "string" || !model.id.trim() || model.id !== model.id.trim()) {
+        throw new Error("model id must be a non-empty trimmed string");
+    }
+    if (model.name !== undefined && (typeof model.name !== "string" || !model.name.length))
+        throw new Error("model name must be a non-empty string");
+    if (model.reasoning !== undefined && typeof model.reasoning !== "boolean") {
+        throw new Error("model reasoning must be a boolean");
+    }
+    if (model.api !== undefined && (typeof model.api !== "string" || !/^[a-z][a-z0-9-]*$/.test(model.api))) {
+        throw new Error("model api must be a protocol name");
+    }
+    if (model.input !== undefined && (!Array.isArray(model.input) || !model.input.length ||
+        model.input.some((input) => input !== "text" && input !== "image") ||
+        new Set(model.input).size !== model.input.length)) {
+        throw new Error("model input must contain text or image without duplicates");
+    }
+    for (const key of ["contextWindow", "maxTokens"]) {
+        if (model[key] !== undefined && (typeof model[key] !== "number" || !Number.isSafeInteger(model[key]) || model[key] <= 0)) {
+            throw new Error(`model ${key} must be a positive integer`);
+        }
+    }
+    if (model.cost !== undefined) {
+        const cost = record(model.cost, "model cost");
+        only(cost, COST_KEYS, "model cost");
+        for (const key of COST_KEYS) {
+            if (typeof cost[key] !== "number" || !Number.isFinite(cost[key]) || cost[key] < 0) {
+                throw new Error(`model cost ${key} must be a non-negative finite number`);
+            }
+        }
+    }
+    return structuredClone(model);
+}
+/** Strict import boundary: unknown fields are rejected, never treated as masked secrets. */
+export function normalizeAgentSnapshot(raw) {
+    const snapshot = record(raw, "agent snapshot");
+    only(snapshot, ["files", "providers"], "agent snapshot");
+    const files = record(snapshot.files, "snapshot files");
+    only(files, ["SYSTEM.md", "AGENTS.md"], "snapshot files");
+    for (const name of ["SYSTEM.md", "AGENTS.md"]) {
+        if (files[name] !== null && typeof files[name] !== "string") {
+            throw new Error(`${name} must be a string or null`);
+        }
+    }
+    const providers = Object.fromEntries(Object.entries(record(snapshot.providers, "snapshot providers")).map(([id, value]) => {
+        if (id.length > 100 || !/^[a-z0-9][a-z0-9._-]*$/.test(id) || ["constructor", "prototype"].includes(id)) {
+            throw new Error("invalid snapshot provider id");
+        }
+        const provider = record(value, "snapshot provider");
+        only(provider, ["models"], "snapshot provider");
+        if (!Array.isArray(provider.models))
+            throw new Error("snapshot provider models must be an array");
+        const models = provider.models.map(modelDefinition);
+        if (new Set(models.map((model) => model.id)).size !== models.length)
+            throw new Error("duplicate model ids");
+        return [id, { models }];
+    }));
+    return { files: { "SYSTEM.md": files["SYSTEM.md"], "AGENTS.md": files["AGENTS.md"] }, providers };
+}
+/** Project disk metadata before validation, so no nested transport object can escape. */
+export function snapshotProviders(providers = {}) {
+    return Object.fromEntries(Object.entries(providers).flatMap(([id, provider]) => {
+        if (provider.models === undefined)
+            return [];
+        if (!Array.isArray(provider.models))
+            throw new Error("models.json models must be an array");
+        const models = provider.models.map((value) => {
+            const source = record(value, "models.json model");
+            const model = Object.fromEntries(MODEL_KEYS.flatMap((key) => source[key] === undefined ? [] : [[key, source[key]]]));
+            if (source.cost !== undefined) {
+                const cost = record(source.cost, "models.json model cost");
+                model.cost = Object.fromEntries(COST_KEYS.flatMap((key) => cost[key] === undefined ? [] : [[key, cost[key]]]));
+            }
+            return modelDefinition(model);
+        });
+        return [[id, { models }]];
+    }));
+}
+/** Replace only portable fields, retaining excluded fields for matching local model ids. */
+export function mergeSnapshotProviders(local = {}, incoming) {
+    const providers = structuredClone(local);
+    for (const [id, provider] of Object.entries(providers)) {
+        if (!Object.hasOwn(incoming, id)) {
+            delete provider.models;
+        }
+    }
+    for (const [id, { models }] of Object.entries(incoming)) {
+        if (!Object.hasOwn(local, id)) {
+            throw new Error(`provider ${id} must be configured locally before importing models`);
+        }
+        const provider = providers[id];
+        if (provider.models !== undefined && !Array.isArray(provider.models))
+            throw new Error("models.json models must be an array");
+        const existing = new Map((provider.models ?? []).map((value) => {
+            const model = record(value, "models.json model");
+            return [model.id, model];
+        }));
+        provider.models = models.map((model) => {
+            const retained = { ...existing.get(model.id) };
+            for (const key of MODEL_KEYS)
+                delete retained[key];
+            return { ...retained, ...model };
+        });
+    }
+    return providers;
+}

package/dist/agent/config.js

@@ -6,8 +6,10 @@ import { promises as fs } from "node:fs";
 import { join, resolve, sep } from "node:path";
 import { isProviderApi, validateEndpoint, validateProviderSetup } from "../core/types.js";
 import { pierPath } from "../paths.js";
+import { mergeSnapshotProviders, normalizeAgentSnapshot, snapshotProviders } from "./config-sync.js";
 const GLOBAL_FILES = ["SYSTEM.md", "AGENTS.md", "settings.json", "models.json"];
 const PROJECT_FILES = ["AGENTS.md"];
+const SNAPSHOT_FILES = ["SYSTEM.md", "AGENTS.md", "models.json"];
 const RESOURCE_DEPTH = 3; // extensions/skills nest at most a couple of levels
 /** Pier owns the Pi runtime dir: config lives in the syncable `~/.pier/pi`
  * repo, not `~/.pi`. main.ts exports this as PI_CODING_AGENT_DIR so the SDK's
@@ -16,16 +18,17 @@ export const defaultAgentDir = () => process.env.PI_CODING_AGENT_DIR ?? pierPath
 /** Stable mask: mapped back by field, without exposing key fragments. */
 const maskKey = (_key) => "••••••••";
 const missing = (err) => err instanceof Error && "code" in err && err.code === "ENOENT";
-const readOptional = async (path) => {
+const readNullable = async (path) => {
     try {
         return await fs.readFile(path, "utf8");
     }
     catch (err) {
         if (missing(err))
-            return "";
+            return null;
         throw err;
     }
 };
+const readOptional = async (path) => (await readNullable(path)) ?? "";
 const pathExists = async (path) => {
     try {
         await fs.access(path);
@@ -57,9 +60,14 @@ const atomicWrite = async (path, data, mode = 0o644) => {
 export class PiConfigStore {
     agentDir;
     #writes = Promise.resolve();
+    #rollbackFailed = false;
     constructor(agentDir = defaultAgentDir()) {
         this.agentDir = agentDir;
     }
+    #assertSnapshot() {
+        if (this.#rollbackFailed)
+            throw new Error("Configuration rollback failed; repair agent files before restarting");
+    }
     get globalDir() {
         return this.agentDir;
     }
@@ -87,6 +95,8 @@ export class PiConfigStore {
     async readFile(scope, name) {
         const path = this.filePath(scope, name);
         await this.#writes;
+        if (scope.kind === "global")
+            this.#assertSnapshot();
         const raw = await readOptional(path);
         return name === "models.json" ? maskModels(raw) : raw;
     }
@@ -104,6 +114,7 @@ export class PiConfigStore {
     }
     async providerStructures() {
         await this.#writes;
+        this.#assertSnapshot();
         const raw = await readOptional(join(this.agentDir, "models.json"));
         const parsed = parseModels(raw);
         const out = {};
@@ -199,8 +210,89 @@ export class PiConfigStore {
             }
         });
     }
+    exportSnapshot() {
+        return this.#withWrite(async () => {
+            const [system, agents, raw] = await Promise.all(SNAPSHOT_FILES.map((name) => readNullable(join(this.agentDir, name))));
+            const parsed = raw?.trim() ? parseModels(raw) : {};
+            if (!parsed)
+                throw new Error("models.json must be valid JSON before exporting configuration");
+            return normalizeAgentSnapshot({
+                files: { "SYSTEM.md": system, "AGENTS.md": agents },
+                providers: snapshotProviders(parsed.providers),
+            });
+        });
+    }
+    async applySnapshot(snapshot, commit) {
+        const incoming = normalizeAgentSnapshot(snapshot);
+        await this.#withWrite(async () => {
+            const names = SNAPSHOT_FILES;
+            const before = await Promise.all(names.map((name) => readNullable(join(this.agentDir, name))));
+            const raw = before[2];
+            const parsed = raw?.trim() ? parseModels(raw) : {};
+            if (!parsed)
+                throw new Error("models.json must be valid JSON before importing configuration");
+            const providers = mergeSnapshotProviders(parsed.providers, incoming.providers);
+            const models = JSON.stringify(providers) === JSON.stringify(parsed.providers ?? {})
+                ? raw : `${JSON.stringify({ ...parsed, providers }, null, 2)}\n`;
+            const after = [incoming.files["SYSTEM.md"], incoming.files["AGENTS.md"], models];
+            const changes = names.flatMap((name, index) => before[index] === after[index] ? [] : [{
+                    path: join(this.agentDir, name), before: before[index], after: after[index],
+                    temp: join(this.agentDir, `${name}.${process.pid}.${randomUUID()}.tmp`),
+                    mode: name === "models.json" ? 0o600 : 0o644,
+                }]);
+            const applied = [];
+            try {
+                // Prepare every replacement before touching a live file.
+                if (changes.length)
+                    await fs.mkdir(this.agentDir, { recursive: true });
+                for (const change of changes) {
+                    if (change.after !== null)
+                        await fs.writeFile(change.temp, change.after, { mode: change.mode });
+                }
+                for (const change of changes) {
+                    if (change.after === null)
+                        await fs.unlink(change.path);
+                    else
+                        await fs.rename(change.temp, change.path);
+                    applied.push(change);
+                }
+                commit?.(changes.length > 0);
+            }
+            catch (err) {
+                const errors = [err];
+                for (const change of applied.reverse()) {
+                    try {
+                        if (change.before === null)
+                            await fs.unlink(change.path);
+                        else
+                            await atomicWrite(change.path, change.before, change.mode);
+                    }
+                    catch (rollback) {
+                        this.#rollbackFailed = true;
+                        errors.push(rollback);
+                    }
+                }
+                for (const change of changes) {
+                    try {
+                        await fs.unlink(change.temp);
+                    }
+                    catch (cleanup) {
+                        if (!missing(cleanup))
+                            errors.push(cleanup);
+                    }
+                }
+                if (errors.length > 1)
+                    throw new AggregateError(errors, "configuration import rollback failed");
+                throw err;
+            }
+        });
+    }
+    /** Pi loads several files directly; hold the same queue while it opens a session. */
+    withSnapshot(read) {
+        return this.#withWrite(read);
+    }
     #withWrite(write) {
-        const result = this.#writes.then(write);
+        const result = this.#writes.then(() => { this.#assertSnapshot(); return write(); });
         this.#writes = result.then(() => undefined, () => undefined);
         return result;
     }

package/dist/agent/events.js

@@ -203,9 +203,18 @@ export function toSessionEvents(e) {
             ];
             if (failure)
                 out.push({ type: "error", message: failure });
-            out.push({ type: "state", state: "idle" });
             return out;
         }
+        // Pi's own "the run-active flag is now false": `_emitAgentSettled` clears
+        // `isStreaming` one statement before emitting this, and reaches it from the
+        // finally of the prompt — many microtasks after the last `agent_end`. Idle
+        // rides on it rather than on the turn ending, so the seam's `state` getter
+        // and this stream stop being two derivations of one fact (§5): a waiter the
+        // idle wakes now re-reads `state` as idle instead of re-arming for an event
+        // that is already spent. It is also the truthful moment — Pi's
+        // auto-compaction and queued continuations run past `agent_end`.
+        case "agent_settled":
+            return [{ type: "state", state: "idle" }];
         case "message_start": {
             // Pi emits this for every message entering the context; the user ones are
             // what a client can't know about (queued/steered messages, IM traffic).

package/dist/agent/pi.js

@@ -112,8 +112,8 @@ export class PiSession {
     /** "What I just wrote is not in your listing yet." The factory retains a
      *  scan for a few seconds, which is exactly the window a rename lands in:
      *  every surface would re-read the old title and keep it until some
-     *  unrelated event moved the list again. Same drop `create` and `fork`
-     *  do — a callback only because the session is what knows it happened. */
+     *  unrelated event moved the list again. Same drop `create` does — a
+     *  callback only because the session is what knows it happened. */
     wrote = () => { }, retention = { value: "long" }) {
         this.pi = pi;
         this.pinned = pinned;
@@ -183,7 +183,24 @@ export class PiSession {
             followUp: [...this.pi.getFollowUpMessages()],
         };
     }
+    /** A system input handed to a streaming session goes into Pi's *agent*
+     *  queue, and the arrays above are the *session's* — they only ever hold
+     *  text a `prompt`/`steer`/`followUp` call queued. So a task message sitting
+     *  in front of a running turn is in neither the queue nor the transcript,
+     *  and this list is the only thing that says it exists. */
+    queuedInputs = [];
+    async pendingSystemInputs() {
+        // Pi drains its follow-up queue before the turn ends, so an idle session
+        // has nothing in flight. Anything still listed was aborted or cleared, and
+        // calling that queued would leave its sender waiting on it forever (§5b).
+        if (!this.pi.isStreaming)
+            this.queuedInputs.length = 0;
+        return [...this.queuedInputs];
+    }
     async clearQueue() {
+        // Not among the texts returned — a system input is nobody's draft — but
+        // dropped all the same, so its sender stops being told it is on its way.
+        this.queuedInputs.length = 0;
         return this.pi.clearQueue();
     }
     async history() {
@@ -290,7 +307,22 @@ export class PiSession {
         // the summary too.
         await this.whenCompacted();
         this.live();
-        return this.pi.sendCustomMessage({ customType: "pier.system-input", content: text, display: true, details: origin }, { triggerTurn: true, deliverAs: mode === "prompt" ? undefined : mode });
+        // Read here, not before the wait, and whatever the mode says: a turn is
+        // running, so the call below queues this input rather than starting one.
+        const queued = this.pi.isStreaming;
+        if (queued)
+            this.queuedInputs.push(origin);
+        try {
+            return await this.pi.sendCustomMessage({ customType: "pier.system-input", content: text, display: true, details: origin }, { triggerTurn: true, deliverAs: mode === "prompt" ? undefined : mode });
+        }
+        catch (error) {
+            // Refused: nothing is in flight, and the caller is about to retry. The
+            // turn may have ended while we waited, so the entry may be gone already.
+            const at = this.queuedInputs.indexOf(origin);
+            if (at >= 0)
+                this.queuedInputs.splice(at, 1);
+            throw error;
+        }
     }
     abort() {
         return this.pi.abort();
@@ -302,11 +334,11 @@ export class PiSession {
             if (piEvent.type === "agent_end")
                 retryPending = piEvent.willRetry === true;
             if (piEvent.type === "agent_settled" && retryPending) {
-                // Aborting Pi during retry backoff produces no final agent_end.
+                // Aborting Pi during retry backoff produces no final agent_end, so the
+                // turn has to be ended here. The idle is not: `agent_settled` carries
+                // it through the table below like any other settle.
                 retryPending = false;
                 fn({ type: "turn-end", text: "", meta: this.lastTurnMeta() });
-                fn({ type: "state", state: "idle" });
-                return;
             }
             for (const payload of toSessionEvents(piEvent)) {
                 fn(payload.type === "turn-end" ? { ...payload, meta: this.lastTurnMeta() } : payload);
@@ -377,7 +409,7 @@ export class PiAgentFactory {
     located = new Map();
     /** That same scan, retained for LIST_TTL_MS instead of paid once per asking
      *  surface — one workspace event has three (sidebar, Activity, task lookups).
-     *  Dropped on create/fork; ids appear for reasons this factory never sees, so
+     *  Dropped on create; ids appear for reasons this factory never sees, so
      *  a miss that decides something re-lists rather than trusts it (`resume`). */
     listing;
     refreshQueue = Promise.resolve();
@@ -596,7 +628,10 @@ export class PiAgentFactory {
         await loader.reload();
         return loader;
     }
-    async open(cwd, sessionManager, opts = { cwd }) {
+    open(cwd, sessionManager, opts = { cwd }) {
+        return this.providerConfig.withSnapshot(() => this.openSnapshot(cwd, sessionManager, opts));
+    }
+    async openSnapshot(cwd, sessionManager, opts) {
         let live;
         // Asked per open, not captured at wiring: a tool whose channel is not
         // configured yet would otherwise cost context on every turn of every
@@ -656,6 +691,13 @@ export class PiAgentFactory {
             resourceLoader: await this.resourceLoader(cwd),
         });
         live = created.session;
+        // Pi's queue defaults to handing over one follow-up per turn boundary, so N
+        // queued messages cost N model turns and anything behind them waits them
+        // out — 11 progress reports drained over 2.5 minutes and put a guidance
+        // message 11 minutes late (2026-09-07). The agent's own setter only flips
+        // the in-memory queue; `session.setFollowUpMode` would persist it to Pi's
+        // settings.json on every open and make it global forever.
+        live.agent.followUpMode = "all";
         const session = new PiSession(live, this.pinned, () => {
             this.listing = undefined;
         }, retention);
@@ -670,26 +712,6 @@ export class PiAgentFactory {
         this.listing = undefined;
         return this.open(opts.cwd, SessionManager.create(opts.cwd), opts);
     }
-    async fork(sourceSessionId, opts) {
-        const infos = await this.listed();
-        const source = infos.find((session) => session.id === sourceSessionId);
-        if (!source)
-            throw new Error(`unknown session: ${sourceSessionId}`);
-        const targetDir = SessionManager.create(opts.cwd).getSessionDir();
-        const manager = SessionManager.open(source.path, targetDir, opts.cwd);
-        const branch = manager.getBranch();
-        const latest = branch.at(-1);
-        const hasPendingToolCall = latest?.type === "message" &&
-            latest.message.role === "assistant" &&
-            Array.isArray(latest.message.content) &&
-            latest.message.content.some((part) => part.type === "toolCall");
-        const leafId = hasPendingToolCall ? latest.parentId : latest?.id;
-        if (!leafId)
-            throw new Error("cannot fork a session before its first persisted input");
-        manager.createBranchedSession(leafId);
-        this.listing = undefined;
-        return this.open(opts.cwd, manager, opts);
-    }
     async resume(sessionId) {
         const known = this.located.get(sessionId);
         if (known) {

package/dist/config-sync-fetch.js

@@ -0,0 +1,84 @@
+// Fetch one configuration document from the operator's source URL: HTTPS with
+// no credentials, redirects followed while they stay HTTPS, JSON capped at
+// 1 MiB so a hostile or broken source cannot exhaust memory.
+export const CONFIG_SYNC_BYTES = 1024 * 1024;
+const MAX_REDIRECTS = 5;
+export function configSourceUrl(raw) {
+    let url;
+    try {
+        url = new URL(raw.trim());
+    }
+    catch {
+        throw new Error("A valid HTTPS source URL is required");
+    }
+    if (url.protocol !== "https:" || url.username || url.password || url.hash || raw.length > 4096) {
+        throw new Error("Source must be HTTPS, without credentials or a fragment");
+    }
+    return url;
+}
+export async function downloadConfig(raw, etag, signal) {
+    let url = configSourceUrl(raw);
+    for (let hop = 0;; hop++) {
+        signal.throwIfAborted();
+        let res;
+        try {
+            res = await fetch(url, {
+                method: "GET", redirect: "manual", signal,
+                headers: { accept: "application/json", ...(etag ? { "if-none-match": etag } : {}) },
+            });
+        }
+        catch {
+            throw new Error(signal.aborted ? "Configuration download timed out or was cancelled" : "Could not connect to source");
+        }
+        const location = res.status >= 300 && res.status < 400 ? res.headers.get("location") : null;
+        if (location) {
+            await res.body?.cancel().catch(() => { });
+            if (hop >= MAX_REDIRECTS)
+                throw new Error("Source redirected too many times");
+            try {
+                url = configSourceUrl(new URL(location, url).href);
+            }
+            catch {
+                throw new Error("Source redirected to a location that is not HTTPS");
+            }
+            continue;
+        }
+        if (res.status !== 200 && res.status !== 304) {
+            await res.body?.cancel().catch(() => { });
+            throw new Error(res.status === 404 || res.status === 410
+                ? "Source link was revoked or does not exist"
+                : `Source returned HTTP ${String(res.status)}`);
+        }
+        const status = res.status === 304 ? 304 : 200;
+        if (status === 200 && !/^application\/json(?:\s*;|$)/i.test(res.headers.get("content-type") ?? "")) {
+            await res.body?.cancel().catch(() => { });
+            throw new Error("Source did not return JSON");
+        }
+        return { status, etag: res.headers.get("etag"), body: await read(res, signal) };
+    }
+}
+async function read(res, signal) {
+    const reader = res.body?.getReader();
+    if (!reader)
+        return "";
+    const chunks = [];
+    let size = 0;
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            size += value.length;
+            if (size > CONFIG_SYNC_BYTES)
+                throw new Error("Configuration exceeds 1 MiB");
+            chunks.push(Buffer.from(value));
+        }
+    }
+    catch (err) {
+        await reader.cancel().catch(() => { });
+        if (err instanceof Error && err.message === "Configuration exceeds 1 MiB")
+            throw err;
+        throw new Error(signal.aborted ? "Configuration download timed out or was cancelled" : "Configuration download failed");
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}

package/dist/config-sync-task.js

@@ -0,0 +1,59 @@
+// The single hourly task owned by the configuration subscription. The task
+// history records manual and scheduled checks; its enabled bit follows the
+// subscription, never a second independently editable switch.
+const OWNER = "config-sync";
+export function configSyncTask(tasks, sync) {
+    let taskId = null;
+    let reconciliation = Promise.resolve();
+    const reconcile = () => {
+        const next = reconciliation.then(async () => {
+            const owned = tasks.list().filter((task) => task.creator === OWNER && !task.archived);
+            for (const extra of owned.slice(1))
+                tasks.archive(extra.id, OWNER);
+            const status = sync.status();
+            if (!owned.length && !status.sourceUrl)
+                return;
+            const draft = {
+                name: "Configuration sync",
+                description: "Checks the configuration source from Settings > Agent every hour.",
+                enabled: status.enabled,
+                trigger: { type: "cron", expression: "23 * * * *", timezone: "UTC" },
+                action: { type: "system", name: OWNER },
+                callback: { type: "none" },
+                timeoutSeconds: 30,
+            };
+            const task = owned[0];
+            if (!task)
+                taskId = (await tasks.create(draft, OWNER)).id;
+            else {
+                taskId = task.id;
+                if (Object.entries(draft).some(([key, value]) => JSON.stringify(task[key]) !== JSON.stringify(value))) {
+                    await tasks.update(task.id, draft, OWNER);
+                }
+            }
+        });
+        // A failed reconciliation must be retryable, but the caller still receives
+        // the original rejection and reports it on its originating surface.
+        reconciliation = next.then(() => undefined, () => undefined);
+        return next;
+    };
+    const run = async () => {
+        await reconcile();
+        if (!taskId || !sync.status().enabled)
+            throw new Error("Configuration subscription is paused");
+        const active = tasks.activeRun(taskId);
+        const started = active ?? tasks.run(taskId, null, "manual");
+        const done = await tasks.waitForRun(started.id);
+        if (done.state !== "succeeded")
+            throw new Error(done.error ?? `Configuration sync ${done.state}`);
+        return done.result?.type === "system" ? done.result.text : "Configuration sync finished";
+    };
+    return {
+        reconcile,
+        run,
+        status: () => ({
+            ...sync.status(), taskId,
+            nextRunAt: taskId ? tasks.get(taskId).nextRunAt : null,
+        }),
+    };
+}