@chibitek/chibi 0.1.160 → 0.1.162

package/dist-server/openmausbot.js

@@ -20622,18 +20622,19 @@ var init_config = __esm({
        * marketplace checks) and personal skills (~/.agents/skills,
        * $CODEX_HOME/skills). */
       codexUserMcp: external_exports.boolean().optional(),
-      /** LLM-generated titles for new bot threads. Off until explicitly
-       * enabled; a one-shot that fails or answers junk leaves the first-message
-       * snippet in place — see llmThreadTitlesEnabled. */
+      /** LLM-generated titles for new bot threads. Off until explicitly enabled; a one-shot
+       * that fails or answers junk leaves the first-message snippet in place — see llmThreadTitlesEnabled. */
       llmThreadTitles: external_exports.boolean().optional(),
-      /** Small internal jobs (thread titles) run on Apple Intelligence on this
-       * Mac when it is available. On unless set to false. */
-      onDeviceHelpers: external_exports.boolean().optional()
+      /** Small internal jobs (thread titles) run on Apple Intelligence on this Mac when available. On unless false. */
+      onDeviceHelpers: external_exports.boolean().optional(),
+      /** Mirror routines into private Mochii tasks (server/routine-mochii-sync.ts). Off unless true; no Settings toggle. */
+      routineMochiiSync: external_exports.boolean().optional()
     });
     addonsConfigSchema = external_exports.object(
       Object.fromEntries(ADDONS.map((addon) => [addon.id, external_exports.boolean().optional()]))
     ).strict();
     setupProgressSchema = external_exports.object({
+      foundationRoles: external_exports.array(external_exports.enum(["assistant", "inbox", "research", "coder", "community", "ops"])).max(3).optional(),
       picks: external_exports.array(external_exports.string().trim().min(1).max(40)).max(20).optional(),
       chibitek: external_exports.boolean().optional(),
       steps: external_exports.record(external_exports.string().trim().min(1).max(60), external_exports.enum(["done", "skipped"])).refine((steps) => Object.keys(steps).length <= 60, "too many setup steps").optional(),
@@ -25444,6 +25445,19 @@ var init_mcp_tool_ref = __esm({
   }
 });
 
+// server/checkpoint-recovery.ts
+function isBrokenAntigravityCheckpoint(driverKind, message2) {
+  return driverKind === "antigravityAgent" && message2.includes("could not find doneCh for checkpoint");
+}
+function isAntigravityCheckpointReply(driverKind, text4) {
+  return driverKind === "antigravityAgent" && /^Agent execution error: could not find doneCh for checkpoint\s*$/.test(text4.trim());
+}
+var init_checkpoint_recovery = __esm({
+  "server/checkpoint-recovery.ts"() {
+    "use strict";
+  }
+});
+
 // server/resume-recovery.ts
 function classifyResumeFailure(state2) {
   if (state2.producedOutput || state2.promptSubmitted) return "after-accept";
@@ -26428,6 +26442,12 @@ function createAcpDriver(support12) {
         session.acp.failAll(new Error("turn settled"));
         session.current = null;
         active.delete(threadId);
+        if (isAntigravityCheckpointReply(DRIVER_KIND8, current.state.text)) {
+          ok = false;
+          stopReason = "invalid_checkpoint";
+          emit({ ...base3(threadId, current.turnId), type: "runtime.error", message: current.state.text.trim() });
+          closeSession(threadId, "invalid-checkpoint");
+        }
         current.flushAssistantText();
         let finalOk = ok;
         let finalStopReason = stopReason;
@@ -27234,7 +27254,8 @@ ${instructed.text}` : instructed.text;
                 type: "runtime.error",
                 message: errorMessage
               });
-              settle(threadId, session, false, reason ?? "failed");
+              if (isBrokenAntigravityCheckpoint(DRIVER_KIND8, errorMessage)) closeSession(threadId, "invalid-checkpoint");
+              settle(threadId, session, false, isBrokenAntigravityCheckpoint(DRIVER_KIND8, errorMessage) ? "invalid_checkpoint" : reason ?? "failed");
             }
           } catch (e) {
             if (!state2.settled) {
@@ -27251,10 +27272,10 @@ ${instructed.text}` : instructed.text;
                 ...needsAuth ? { setup: true } : {},
                 ...failure ? { failure } : {}
               });
-              if ((logAuth || !needsAuth && (stalled || e?.acpSessionFailure === true || code === "upstream_outage")) && session.child.exitCode === null && !session.closing) {
+              if ((logAuth || !needsAuth && (stalled || isBrokenAntigravityCheckpoint(DRIVER_KIND8, message2) || e?.acpSessionFailure === true || code === "upstream_outage")) && session.child.exitCode === null && !session.closing) {
                 closeSession(threadId, logAuth ? "provider-auth" : stalled ? "prompt-stall" : "rpc-failure");
               }
-              settle(threadId, session, false, needsAuth ? "auth_required" : "rpc_error");
+              settle(threadId, session, false, needsAuth ? "auth_required" : isBrokenAntigravityCheckpoint(DRIVER_KIND8, message2) ? "invalid_checkpoint" : "rpc_error");
             }
           }
         })();
@@ -27343,6 +27364,7 @@ var init_core3 = __esm({
     init_mcp_tool_images();
     init_mcp_tool_ref();
     init_redact2();
+    init_checkpoint_recovery();
     init_resume_recovery();
     init_retry();
     init_engine_failure();

package/dist-server/pair-cli.js

@@ -20622,18 +20622,19 @@ var init_config = __esm({
        * marketplace checks) and personal skills (~/.agents/skills,
        * $CODEX_HOME/skills). */
       codexUserMcp: external_exports.boolean().optional(),
-      /** LLM-generated titles for new bot threads. Off until explicitly
-       * enabled; a one-shot that fails or answers junk leaves the first-message
-       * snippet in place — see llmThreadTitlesEnabled. */
+      /** LLM-generated titles for new bot threads. Off until explicitly enabled; a one-shot
+       * that fails or answers junk leaves the first-message snippet in place — see llmThreadTitlesEnabled. */
       llmThreadTitles: external_exports.boolean().optional(),
-      /** Small internal jobs (thread titles) run on Apple Intelligence on this
-       * Mac when it is available. On unless set to false. */
-      onDeviceHelpers: external_exports.boolean().optional()
+      /** Small internal jobs (thread titles) run on Apple Intelligence on this Mac when available. On unless false. */
+      onDeviceHelpers: external_exports.boolean().optional(),
+      /** Mirror routines into private Mochii tasks (server/routine-mochii-sync.ts). Off unless true; no Settings toggle. */
+      routineMochiiSync: external_exports.boolean().optional()
     });
     addonsConfigSchema = external_exports.object(
       Object.fromEntries(ADDONS.map((addon) => [addon.id, external_exports.boolean().optional()]))
     ).strict();
     setupProgressSchema = external_exports.object({
+      foundationRoles: external_exports.array(external_exports.enum(["assistant", "inbox", "research", "coder", "community", "ops"])).max(3).optional(),
       picks: external_exports.array(external_exports.string().trim().min(1).max(40)).max(20).optional(),
       chibitek: external_exports.boolean().optional(),
       steps: external_exports.record(external_exports.string().trim().min(1).max(60), external_exports.enum(["done", "skipped"])).refine((steps) => Object.keys(steps).length <= 60, "too many setup steps").optional(),
@@ -25444,6 +25445,19 @@ var init_mcp_tool_ref = __esm({
   }
 });
 
+// server/checkpoint-recovery.ts
+function isBrokenAntigravityCheckpoint(driverKind, message2) {
+  return driverKind === "antigravityAgent" && message2.includes("could not find doneCh for checkpoint");
+}
+function isAntigravityCheckpointReply(driverKind, text4) {
+  return driverKind === "antigravityAgent" && /^Agent execution error: could not find doneCh for checkpoint\s*$/.test(text4.trim());
+}
+var init_checkpoint_recovery = __esm({
+  "server/checkpoint-recovery.ts"() {
+    "use strict";
+  }
+});
+
 // server/resume-recovery.ts
 function classifyResumeFailure(state2) {
   if (state2.producedOutput || state2.promptSubmitted) return "after-accept";
@@ -26428,6 +26442,12 @@ function createAcpDriver(support12) {
         session.acp.failAll(new Error("turn settled"));
         session.current = null;
         active.delete(threadId);
+        if (isAntigravityCheckpointReply(DRIVER_KIND8, current.state.text)) {
+          ok = false;
+          stopReason = "invalid_checkpoint";
+          emit({ ...base3(threadId, current.turnId), type: "runtime.error", message: current.state.text.trim() });
+          closeSession(threadId, "invalid-checkpoint");
+        }
         current.flushAssistantText();
         let finalOk = ok;
         let finalStopReason = stopReason;
@@ -27234,7 +27254,8 @@ ${instructed.text}` : instructed.text;
                 type: "runtime.error",
                 message: errorMessage
               });
-              settle(threadId, session, false, reason ?? "failed");
+              if (isBrokenAntigravityCheckpoint(DRIVER_KIND8, errorMessage)) closeSession(threadId, "invalid-checkpoint");
+              settle(threadId, session, false, isBrokenAntigravityCheckpoint(DRIVER_KIND8, errorMessage) ? "invalid_checkpoint" : reason ?? "failed");
             }
           } catch (e) {
             if (!state2.settled) {
@@ -27251,10 +27272,10 @@ ${instructed.text}` : instructed.text;
                 ...needsAuth ? { setup: true } : {},
                 ...failure ? { failure } : {}
               });
-              if ((logAuth || !needsAuth && (stalled || e?.acpSessionFailure === true || code === "upstream_outage")) && session.child.exitCode === null && !session.closing) {
+              if ((logAuth || !needsAuth && (stalled || isBrokenAntigravityCheckpoint(DRIVER_KIND8, message2) || e?.acpSessionFailure === true || code === "upstream_outage")) && session.child.exitCode === null && !session.closing) {
                 closeSession(threadId, logAuth ? "provider-auth" : stalled ? "prompt-stall" : "rpc-failure");
               }
-              settle(threadId, session, false, needsAuth ? "auth_required" : "rpc_error");
+              settle(threadId, session, false, needsAuth ? "auth_required" : isBrokenAntigravityCheckpoint(DRIVER_KIND8, message2) ? "invalid_checkpoint" : "rpc_error");
             }
           }
         })();
@@ -27343,6 +27364,7 @@ var init_core3 = __esm({
     init_mcp_tool_images();
     init_mcp_tool_ref();
     init_redact2();
+    init_checkpoint_recovery();
     init_resume_recovery();
     init_retry();
     init_engine_failure();

package/dist-server/server/checkpoint-recovery.js

@@ -0,0 +1,18 @@
+/** This identifies an unusable saved session, never permission to replay a
+ * submitted prompt. Only a subsequent explicit turn may rebuild the context. */
+export function isBrokenAntigravityCheckpoint(driverKind, message) {
+    return driverKind === "antigravityAgent" && message.includes("could not find doneCh for checkpoint");
+}
+export function invalidateBrokenCheckpoint(store, botId, driverKind, event) {
+    if (event.providerInstanceId && isBrokenAntigravityCheckpoint(driverKind, event.message)) {
+        // Undefined is absent on disk and engineIsFresh rebuilds from Atomic's
+        // transcript on the next send, including after an application restart.
+        store.setResumeCursor(botId, event.providerInstanceId, undefined, event.threadId);
+    }
+}
+/** Antigravity also sends its execution failure as a chunked assistant reply
+ * followed by end_turn. A quoted error inside a normal answer is not failure. */
+export function isAntigravityCheckpointReply(driverKind, text) {
+    return driverKind === "antigravityAgent"
+        && /^Agent execution error: could not find doneCh for checkpoint\s*$/.test(text.trim());
+}

package/dist-server/server/config.js

@@ -277,13 +277,13 @@ const featureConfigSchema = z.object({
      * marketplace checks) and personal skills (~/.agents/skills,
      * $CODEX_HOME/skills). */
     codexUserMcp: z.boolean().optional(),
-    /** LLM-generated titles for new bot threads. Off until explicitly
-     * enabled; a one-shot that fails or answers junk leaves the first-message
-     * snippet in place — see llmThreadTitlesEnabled. */
+    /** LLM-generated titles for new bot threads. Off until explicitly enabled; a one-shot
+     * that fails or answers junk leaves the first-message snippet in place — see llmThreadTitlesEnabled. */
     llmThreadTitles: z.boolean().optional(),
-    /** Small internal jobs (thread titles) run on Apple Intelligence on this
-     * Mac when it is available. On unless set to false. */
+    /** Small internal jobs (thread titles) run on Apple Intelligence on this Mac when available. On unless false. */
     onDeviceHelpers: z.boolean().optional(),
+    /** Mirror routines into private Mochii tasks (server/routine-mochii-sync.ts). Off unless true; no Settings toggle. */
+    routineMochiiSync: z.boolean().optional(),
 });
 /** Settings → Add-ons: one workspace switch per bundled add-on
  * (shared/addons.ts). Absent means the add-on's own default. Strict, so a
@@ -293,8 +293,8 @@ const addonsConfigSchema = z.object(Object.fromEntries(ADDONS.map((addon) => [ad
  * it survives cleared site data and is shared by every paired client. Hint
  * ids are short renderer-chosen slugs; the list is capped so a buggy client
  * cannot grow the file without bound. */
-/** The setup wizard's progress (src/lib/setup-wizard.ts SetupProgress). */
 const setupProgressSchema = z.object({
+    foundationRoles: z.array(z.enum(["assistant", "inbox", "research", "coder", "community", "ops"])).max(3).optional(),
     picks: z.array(z.string().trim().min(1).max(40)).max(20).optional(),
     chibitek: z.boolean().optional(),
     steps: z.record(z.string().trim().min(1).max(60), z.enum(["done", "skipped"]))

package/dist-server/server/drivers/acp/core.js

@@ -48,6 +48,7 @@ import { commandSummary, toolDetailPreview } from "../../tool-summary.js";
 import { extractMcpImages } from "../../mcp-tool-images.js";
 import { mcpToolRefFromLabel } from "../../../shared/mcp-tool-ref.js";
 import { redactSecretsInText } from "../../redact.js";
+import { isBrokenAntigravityCheckpoint, isAntigravityCheckpointReply } from "../../checkpoint-recovery.js";
 import { recoveryPromptFor } from "../../resume-recovery.js";
 import { isModelRejection } from "../retry.js";
 import { engineFailureFromCode, isCredentialDead, isOpaqueRequestRejection, logAuthFailure, parseResetAt, resetHintFromData } from "../../engine-failure.js";
@@ -464,14 +465,15 @@ export function createAcpDriver(support) {
                 // turn synchronously must find this session free
                 session.current = null;
                 active.delete(threadId);
+                if (isAntigravityCheckpointReply(DRIVER_KIND, current.state.text)) {
+                    ok = false;
+                    stopReason = "invalid_checkpoint";
+                    emit({ ...base(threadId, current.turnId), type: "runtime.error", message: current.state.text.trim() });
+                    closeSession(threadId, "invalid-checkpoint");
+                }
                 current.flushAssistantText();
-                // `end_turn` with nothing to show for it — no reply, no image, no
-                // tool result — is a lost turn, not a success. An engine can report
-                // exactly that (a provider may cut a reasoning-only stream and
-                // still answer end_turn), and ok:true would end the thread quietly
-                // while the person's message went unanswered. Keep the completion,
-                // but report it as a failure so terminal chips, incidents and
-                // follow-ups see what happened.
+                // A successful end_turn without a reply or tool result is a lost
+                // turn. Report failure so terminal chips and follow-ups reflect it.
                 let finalOk = ok;
                 let finalStopReason = stopReason;
                 if (finalOk && finalStopReason === null && !current.state.producedItem) {
@@ -1467,7 +1469,9 @@ export function createAcpDriver(support) {
                                 type: "runtime.error",
                                 message: errorMessage,
                             });
-                            settle(threadId, session, false, reason ?? "failed");
+                            if (isBrokenAntigravityCheckpoint(DRIVER_KIND, errorMessage))
+                                closeSession(threadId, "invalid-checkpoint");
+                            settle(threadId, session, false, isBrokenAntigravityCheckpoint(DRIVER_KIND, errorMessage) ? "invalid_checkpoint" : reason ?? "failed");
                         }
                     }
                     catch (e) {
@@ -1492,18 +1496,14 @@ export function createAcpDriver(support) {
                                 ...(needsAuth ? { setup: true } : {}),
                                 ...(failure ? { failure } : {}),
                             });
-                            // Internal RPC failures can leave a live child poisoned just
-                            // like a silent prompt. Evict before completion listeners can
-                            // start the next turn. Never replay this accepted prompt: it
-                            // may already have executed tools. The next explicit turn can
-                            // resume the recorded session on a fresh process.
-                            // An agent refused by its provider mid-prompt is still running
-                            // (retrying on its own): it goes too.
-                            if ((logAuth || (!needsAuth && (stalled || e?.acpSessionFailure === true
+                            // Evict unusable sessions without replaying accepted prompts.
+                            // The harness invalidates broken checkpoints durably so the
+                            // next explicit turn rebuilds from the retained transcript.
+                            if ((logAuth || (!needsAuth && (stalled || isBrokenAntigravityCheckpoint(DRIVER_KIND, message) || e?.acpSessionFailure === true
                                 || code === "upstream_outage"))) && session.child.exitCode === null && !session.closing) {
                                 closeSession(threadId, logAuth ? "provider-auth" : stalled ? "prompt-stall" : "rpc-failure");
                             }
-                            settle(threadId, session, false, needsAuth ? "auth_required" : "rpc_error");
+                            settle(threadId, session, false, needsAuth ? "auth_required" : isBrokenAntigravityCheckpoint(DRIVER_KIND, message) ? "invalid_checkpoint" : "rpc_error");
                         }
                     }
                 })();

package/dist-server/server/engine-failover.js

@@ -49,10 +49,10 @@ export const NO_ANSWER_FAILURE = "The engine ended the turn without an answer.";
 function unrecognisedFailure(turn) {
     return { kind: "provider_error", message: turn.lastError ?? NO_ANSWER_FAILURE };
 }
-/** Ways a turn ends failed that are not the engine's fault: the person (or
- * the harness on their behalf) stopped it. Every other failed end moves the
- * turn to the next engine. */
-const NOT_A_PROVIDER_FAILURE = new Set(["interrupted", "cancelled"]);
+/** Stops that must not dispatch the request again: cancellation or a broken
+ * checkpoint whose accepted prompt may already have executed actions.
+ * The next explicit turn rebuilds that checkpoint from retained history. */
+const NOT_A_PROVIDER_FAILURE = new Set(["interrupted", "cancelled", "invalid_checkpoint"]);
 export class FailoverGate {
     turns = new Map();
     onFailure;

package/dist-server/server/index.js

@@ -1,3 +1,4 @@
+import { invalidateBrokenCheckpoint } from "./checkpoint-recovery.js";
 import { createModelExpectation, ModelEvidenceLedger } from "./model-evidence-context.js";
 import { reactToMessage } from "./message-reactions.js";
 import { hasUnboundGoalGuard, goalGuardForEvent, addGoalGuard, removeGoalGuard, runPersonalGoalTurn, updatePersonalGoalReceipt } from "./personal-goal-turn.js";
@@ -175,6 +176,7 @@ import { agentBrowserFrame, agentBrowserIntegration, browserEngineEncryptionKey,
 import { withZipListings } from "./zip-listing.js";
 import { createScreenFrameSource, startPeriodicCapture } from "./screen-frame-source.js";
 import { screenFrameHash, screenSurfaceForTool, screenTouchingTool, settledFrameIsNews } from "./screen-frame-gate.js";
+import { RoutineMochiiSync } from "./routine-mochii-sync.js";
 import { RoutineRequestService } from "./routine-requests.js";
 import { buildBotOverview } from "./bot-overview.js";
 import { ProfileRequestService } from "./profile-requests.js";
@@ -2430,6 +2432,7 @@ function noteNexusLocalMemory(botId) {
     }
 }
 nexusMemory.start();
+const routineMochiiSync = RoutineMochiiSync.start({ dataDir: DATA_DIR, config: () => cfg, listRoutines: () => routines?.listRoutines() ?? [], listRuns: () => routines?.listRuns() ?? [], botName: (id) => store.bot(id)?.name, timeZone: () => routineTimeZone() });
 // Register the Private Bot's Nexus key as soon as there is a Private Bot, so
 // nothing else can register first (Nexus trusts the first key).
 // (Deferred: the store is created further down.)
@@ -8170,22 +8173,20 @@ bus.subscribe((event) => {
             });
             break;
         case "runtime.error":
+            if (bot)
+                invalidateBrokenCheckpoint(store, bot.id, event.providerInstanceId ? registry.get(event.providerInstanceId)?.driverKind : undefined, event);
             if (event.message?.trim())
                 lastTurnError.set(event.threadId, event.message.trim().slice(0, 300));
             pushMessage({
                 role: "bot",
                 kind: "activity",
-                // The category travels with the line so every surface words it the
-                // same way; an error line is never a lost connection either way.
+                // Keep the category consistent across surfaces.
                 // The harness's own stop line is kept whole: it ends with where to fix
                 // the account, which a 160-character cut would drop.
                 tool: { name: `error: ${event.message.slice(0, event.category === "account" || event.category === "failover_exhausted" ? 600 : 160)}`, ok: false, setup: event.setup, ...(event.terminal ? { terminal: true } : {}),
                     ...(event.category ? { errorCategory: event.category } : {}) },
             });
-            // a setup error means the engine could not even start: the bot is
-            // dead until something changes, not merely idle. The next successful
-            // dispatch moves it to working; turn.completed (which follows a setup
-            // failure) is told to leave "dead" alone.
+            // Setup failures remain dead until a later successful dispatch.
             if (event.setup && bot)
                 store.setTaskActivity(bot.id, event.threadId, "dead");
             break;
@@ -11274,7 +11275,7 @@ routines = new RoutineManager({
         }
     },
     interruptGoal: interruptRoutineGroupGoal,
-    onRunChanged: syncRoutineRunToSource,
+    onRunChanged: (run) => { syncRoutineRunToSource(run); routineMochiiSync.poke(); },
     onRunFailed: (run) => {
         if (run.threadId) {
             pendingDelegationWakes.delete(run.threadId);
@@ -25523,7 +25524,7 @@ const gracefulShutdown = createGracefulShutdown({
         () => setupLogins.stopAll(),
         () => flushAllMemoryJournals(),
         // the outbox is already on disk; this only stops its retry timer
-        () => nexusMemory.stop(),
+        () => { nexusMemory.stop(); routineMochiiSync.stop(); },
         () => flushUsageLedger(DATA_DIR),
         () => flushDecisionLog(DATA_DIR),
         () => flushAdminActivity(DATA_DIR),

package/dist-server/server/routine-mochii-sync.js

@@ -0,0 +1,252 @@
+// Mirrors each routine into one private Mochii task: its schedule and next
+// run on the task, and every finished run as a comment. Off unless the
+// install sets features.routineMochiiSync, and it needs the configured
+// `mochii` MCP server, which acts as the signed-in person, so each person's
+// routines land in their own Mochii as their own private tasks.
+//
+// Fail closed: a new task is first created with a content-free title. Only
+// when Mochii answers that it is private and keyed to this routine (the
+// create contract: is_private, idempotency_key, replayed) does routine
+// content follow. An older Mochii that ignores the contract gets its stray
+// task deleted, and sync pauses for a few hours before checking again.
+//
+// No outbox: the routines and their run receipts are already on disk, so each
+// pass compares them with what Mochii has confirmed (routine-mochii-sync.json)
+// and sends the difference. A failed pass is simply retried on the next one.
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { writeFileAtomic } from "./atomic.js";
+import { customMcpServers } from "./config.js";
+import { nexusClientFor, NexusUnavailableError } from "./nexus-memory/client.js";
+import { scheduleText } from "./routine-requests.js";
+const PASS_EVERY_MS = 5 * 60_000;
+const POKE_DELAY_MS = 3_000;
+const BLOCK_MS = 6 * 60 * 60_000;
+/** Runs already finished when a routine is first mirrored: only the latest few become comments. */
+const BACKFILL_RUNS = 5;
+const MAX_COMMENT_CHARS = 4_000;
+const FINISHED = new Set(["completed", "failed", "cancelled", "missed"]);
+const PROBE_TITLE = "Atomic routine";
+export function routineMochiiSyncEnabled(cfg) {
+    return cfg.features?.routineMochiiSync === true && Boolean(customMcpServers(cfg).mochii);
+}
+export const idempotencyKey = (routineId) => `atomic-routine:${routineId}`;
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+export function taskTitle(routine) {
+    return `Routine: ${routine.name}${routine.enabled ? "" : " (paused)"}`;
+}
+export function taskDescription(routine, bot, timeZone) {
+    const next = routine.enabled && routine.nextRunAt != null ? new Date(routine.nextRunAt).toISOString() : "none";
+    return [
+        "Managed by Atomic. Edits made here are replaced on the next sync.",
+        "",
+        `Bot: ${bot ?? routine.botId}`,
+        `Schedule: ${scheduleText(routine.schedule, timeZone)}`,
+        `Status: ${routine.enabled ? "active" : "paused"}`,
+        `Next run: ${next}`,
+        "",
+        "Prompt:",
+        routine.prompt,
+    ].join("\n");
+}
+export function runComment(run) {
+    const when = new Date(run.finishedAt ?? run.scheduledFor).toISOString();
+    const body = (run.status === "failed" ? run.error ?? run.output : run.output ?? run.error)?.trim();
+    const clipped = body && body.length > MAX_COMMENT_CHARS ? `${body.slice(0, MAX_COMMENT_CHARS)}\n\n(cut short; the full report is in Atomic)` : body;
+    return `Run ${run.status} · ${when}${run.manual ? " · started by hand" : ""}${clipped ? `\n\n${clipped}` : ""}`;
+}
+export class RoutineMochiiSync {
+    path;
+    now;
+    state;
+    client = null;
+    clientKey = "";
+    running = null;
+    poked;
+    timer;
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+        this.path = join(deps.dataDir, "routine-mochii-sync.json");
+        this.now = deps.now ?? Date.now;
+        this.state = this.load();
+    }
+    static start(deps) {
+        const sync = new RoutineMochiiSync(deps);
+        sync.start();
+        return sync;
+    }
+    start() {
+        this.timer ??= setInterval(() => void this.pass(), PASS_EVERY_MS);
+        this.timer.unref?.();
+        this.poke();
+    }
+    stop() {
+        clearInterval(this.timer);
+        clearTimeout(this.poked);
+        this.timer = undefined;
+        void this.client?.close();
+        this.client = null;
+    }
+    /** A run changed: sync soon rather than waiting for the next pass. */
+    poke() {
+        if (this.poked || !routineMochiiSyncEnabled(this.deps.config()))
+            return;
+        this.poked = setTimeout(() => {
+            this.poked = undefined;
+            void this.pass();
+        }, POKE_DELAY_MS);
+        this.poked.unref?.();
+    }
+    status() {
+        return {
+            enabled: routineMochiiSyncEnabled(this.deps.config()),
+            mirrored: Object.keys(this.state.tasks).length,
+            blockedUntil: this.state.blockedUntil ?? null,
+            blockedReason: this.state.blockedReason ?? null,
+        };
+    }
+    /** One reconcile pass; concurrent callers share it. */
+    pass() {
+        this.running ??= this.reconcile()
+            .catch((error) => this.log(`pass stopped: ${error instanceof Error ? error.message : String(error)}`))
+            .finally(() => { this.running = null; });
+        return this.running;
+    }
+    async reconcile() {
+        const cfg = this.deps.config();
+        if (!routineMochiiSyncEnabled(cfg))
+            return;
+        if (this.state.blockedUntil && this.now() < this.state.blockedUntil)
+            return;
+        const client = this.clientFor(cfg);
+        if (!client)
+            return;
+        const routines = this.deps.listRoutines();
+        const runs = this.deps.listRuns();
+        for (const routine of routines) {
+            const mine = runs.filter((run) => run.routineId === routine.id && FINISHED.has(run.status));
+            try {
+                if (!(await this.mirror(client, routine, mine)))
+                    return;
+            }
+            catch (error) {
+                if (error instanceof NexusUnavailableError)
+                    throw error;
+                this.log(`routine ${routine.id}: ${error instanceof Error ? error.message : String(error)}`);
+                // The task is gone from Mochii: forget it so the next pass creates it again.
+                if (/not found|404/i.test(String(error)))
+                    this.forget(routine.id);
+            }
+        }
+        const live = new Set(routines.map((routine) => routine.id));
+        for (const [routineId, mirrored] of Object.entries(this.state.tasks)) {
+            if (live.has(routineId))
+                continue;
+            try {
+                await client.call("update_task", { id: mirrored.taskId, status: "cancelled" });
+                await client.call("add_comment", { task_id: mirrored.taskId, content: "This routine was deleted in Atomic." });
+            }
+            catch (error) {
+                if (error instanceof NexusUnavailableError)
+                    throw error;
+            }
+            this.forget(routineId);
+        }
+    }
+    /** False when Mochii failed the privacy check: stop the whole pass. */
+    async mirror(client, routine, finished) {
+        let mirrored = this.state.tasks[routine.id];
+        if (!mirrored) {
+            const taskId = await this.createPrivate(client, routine.id);
+            if (!taskId)
+                return false;
+            const byAge = [...finished].sort((a, b) => (a.finishedAt ?? a.scheduledFor) - (b.finishedAt ?? b.scheduledFor));
+            mirrored = { taskId, fingerprint: "", runs: byAge.slice(0, -BACKFILL_RUNS).map((run) => run.id) };
+            this.state.tasks[routine.id] = mirrored;
+            this.save();
+        }
+        const title = taskTitle(routine);
+        const description = taskDescription(routine, this.deps.botName(routine.botId), this.deps.timeZone());
+        const due = routine.enabled && routine.nextRunAt != null ? new Date(routine.nextRunAt).toISOString() : undefined;
+        const fingerprint = JSON.stringify([title, description, due]);
+        if (fingerprint !== mirrored.fingerprint) {
+            await client.call("update_task", { id: mirrored.taskId, title, description, status: "pending", ...(due ? { due_date: due } : {}) });
+            mirrored.fingerprint = fingerprint;
+            this.save();
+        }
+        const posted = new Set(mirrored.runs);
+        const fresh = finished
+            .filter((run) => !posted.has(run.id))
+            .sort((a, b) => (a.finishedAt ?? a.scheduledFor) - (b.finishedAt ?? b.scheduledFor));
+        for (const run of fresh) {
+            await client.call("add_comment", { task_id: mirrored.taskId, content: runComment(run) });
+            mirrored.runs.push(run.id);
+            this.save();
+        }
+        const kept = new Set(finished.map((run) => run.id));
+        if (mirrored.runs.some((id) => !kept.has(id))) {
+            mirrored.runs = mirrored.runs.filter((id) => kept.has(id));
+            this.save();
+        }
+        return true;
+    }
+    /** Creates (or, after a crash, gets back) the routine's task with a content-free title. */
+    async createPrivate(client, routineId) {
+        const key = idempotencyKey(routineId);
+        const body = await client.call("create_task", { title: PROBE_TITLE, is_private: true, idempotency_key: key });
+        const task = record(body.data);
+        const taskId = typeof task?.id === "string" ? task.id : null;
+        if (taskId && task?.is_private === true && task.idempotency_key === key && typeof body.replayed === "boolean")
+            return taskId;
+        if (taskId && task?.is_private !== true) {
+            await client.call("delete_task", { id: taskId }).catch((error) => this.log(`could not remove a non-private task ${taskId}: ${String(error)}`));
+        }
+        this.state.blockedUntil = this.now() + BLOCK_MS;
+        this.state.blockedReason = "Mochii does not support private routine tasks yet";
+        this.save();
+        this.log(`${this.state.blockedReason}; nothing was sent, checking again later`);
+        return null;
+    }
+    forget(routineId) {
+        delete this.state.tasks[routineId];
+        this.save();
+    }
+    clientFor(cfg) {
+        if (this.deps.clientFor)
+            return (this.client ??= this.deps.clientFor(cfg));
+        const spec = customMcpServers(cfg).mochii;
+        const key = JSON.stringify(spec ?? null);
+        if (key !== this.clientKey) {
+            void this.client?.close();
+            this.client = nexusClientFor(spec);
+            this.clientKey = key;
+        }
+        return this.client;
+    }
+    load() {
+        try {
+            if (existsSync(this.path)) {
+                const parsed = record(JSON.parse(readFileSync(this.path, "utf8")));
+                if (parsed && record(parsed.tasks))
+                    return parsed;
+            }
+        }
+        catch (error) {
+            this.log(`ignoring unreadable ${this.path}: ${String(error)}`);
+        }
+        return { tasks: {} };
+    }
+    save() {
+        if (this.state.blockedUntil && this.now() >= this.state.blockedUntil) {
+            delete this.state.blockedUntil;
+            delete this.state.blockedReason;
+        }
+        writeFileAtomic(this.path, JSON.stringify(this.state, null, 2));
+    }
+    log(message) {
+        (this.deps.log ?? ((line) => console.warn(`[routine-mochii-sync] ${line}`)))(message);
+    }
+}