@pellux/goodvibes-agent 1.7.0 → 1.8.1

package/dist/package/main.js

@@ -4463,7 +4463,7 @@ var init_mcp = __esm(() => {
 // node_modules/@pellux/goodvibes-sdk/dist/platform/version.js
 import { readFileSync as readFileSync3 } from "fs";
 import { join as join4 } from "path";
-var version = "1.5.0", VERSION2;
+var version = "1.6.1", VERSION2;
 var init_version = __esm(() => {
   try {
     const pkg = JSON.parse(readFileSync3(join4(import.meta.dir, "..", "..", "package.json"), "utf-8"));
@@ -264151,8 +264151,8 @@ var FOUNDATION_METADATA;
 var init_foundation_metadata = __esm(() => {
   FOUNDATION_METADATA = {
     productId: "goodvibes",
-    productVersion: "1.5.0",
-    operatorMethodCount: 329,
+    productVersion: "1.6.1",
+    operatorMethodCount: 333,
     operatorEventCount: 31,
     peerEndpointCount: 6
   };
@@ -264166,7 +264166,7 @@ var init_operator_contract = __esm(() => {
     product: {
       id: "goodvibes",
       surface: "operator",
-      version: "1.5.0"
+      version: "1.6.1"
     },
     auth: {
       modes: [
@@ -290713,6 +290713,322 @@ var init_operator_contract = __esm(() => {
           dangerous: true,
           invokable: false
         },
+        {
+          id: "fleet.archive",
+          title: "Archive Finished Fleet Subtree",
+          description: "Move one FINISHED process subtree (root id + all descendants, every node terminal) out of the live fleet view into the session archive. Honest refusal (archived:false + reason) for an unknown id or a subtree with live members. Archived nodes stay inspectable via fleet.archived.list.",
+          category: "fleet",
+          source: "builtin",
+          access: "authenticated",
+          transport: [
+            "ws"
+          ],
+          scopes: [
+            "write:fleet"
+          ],
+          inputSchema: {
+            type: "object",
+            properties: {
+              id: {
+                type: "string"
+              }
+            },
+            required: [
+              "id"
+            ],
+            additionalProperties: false
+          },
+          outputSchema: {
+            type: "object",
+            properties: {
+              archived: {
+                type: "boolean"
+              },
+              count: {
+                type: "number"
+              },
+              reason: {
+                type: "string"
+              }
+            },
+            required: [
+              "archived",
+              "count"
+            ],
+            additionalProperties: false
+          },
+          invokable: true
+        },
+        {
+          id: "fleet.archived.list",
+          title: "List Archived Fleet Processes",
+          description: "Return the session-archived process nodes (same node shape as fleet.snapshot; still live-derived from the source managers, so usage/cost stay current).",
+          category: "fleet",
+          source: "builtin",
+          access: "authenticated",
+          transport: [
+            "ws"
+          ],
+          scopes: [
+            "read:fleet"
+          ],
+          inputSchema: {
+            type: "object",
+            properties: {},
+            additionalProperties: false
+          },
+          outputSchema: {
+            type: "object",
+            properties: {
+              capturedAt: {
+                type: "number"
+              },
+              nodes: {
+                type: "array",
+                items: {
+                  type: "object",
+                  properties: {
+                    id: {
+                      type: "string"
+                    },
+                    kind: {
+                      type: "string",
+                      enum: [
+                        "agent",
+                        "wrfc-chain",
+                        "wrfc-subtask",
+                        "workflow",
+                        "trigger",
+                        "schedule",
+                        "watcher",
+                        "background-process",
+                        "workstream",
+                        "phase",
+                        "work-item",
+                        "code-index"
+                      ]
+                    },
+                    parentId: {
+                      type: "string"
+                    },
+                    label: {
+                      type: "string"
+                    },
+                    task: {
+                      type: "string"
+                    },
+                    state: {
+                      type: "string",
+                      enum: [
+                        "thinking",
+                        "executing-tool",
+                        "awaiting-approval",
+                        "streaming",
+                        "stalled",
+                        "retrying",
+                        "done",
+                        "failed",
+                        "killed",
+                        "interrupted",
+                        "idle",
+                        "queued",
+                        "paused"
+                      ]
+                    },
+                    startedAt: {
+                      type: "number"
+                    },
+                    completedAt: {
+                      type: "number"
+                    },
+                    elapsedMs: {
+                      type: "number"
+                    },
+                    usage: {
+                      type: "object",
+                      properties: {
+                        inputTokens: {
+                          type: "number"
+                        },
+                        outputTokens: {
+                          type: "number"
+                        },
+                        cacheReadTokens: {
+                          type: "number"
+                        },
+                        cacheWriteTokens: {
+                          type: "number"
+                        },
+                        reasoningTokens: {
+                          type: "number"
+                        },
+                        llmCallCount: {
+                          type: "number"
+                        },
+                        turnCount: {
+                          type: "number"
+                        },
+                        toolCallCount: {
+                          type: "number"
+                        }
+                      },
+                      required: [
+                        "inputTokens",
+                        "outputTokens",
+                        "cacheReadTokens",
+                        "cacheWriteTokens",
+                        "llmCallCount",
+                        "turnCount",
+                        "toolCallCount"
+                      ],
+                      additionalProperties: false
+                    },
+                    model: {
+                      type: "string"
+                    },
+                    provider: {
+                      type: "string"
+                    },
+                    costUsd: {
+                      anyOf: [
+                        {
+                          type: "number"
+                        },
+                        {
+                          type: "null"
+                        }
+                      ]
+                    },
+                    costState: {
+                      type: "string",
+                      enum: [
+                        "priced",
+                        "unpriced",
+                        "estimated"
+                      ]
+                    },
+                    currentActivity: {
+                      type: "object",
+                      properties: {
+                        kind: {
+                          type: "string",
+                          enum: [
+                            "tool",
+                            "output-line",
+                            "phase"
+                          ]
+                        },
+                        text: {
+                          type: "string"
+                        },
+                        toolName: {
+                          type: "string"
+                        },
+                        at: {
+                          type: "number"
+                        }
+                      },
+                      required: [
+                        "kind",
+                        "text",
+                        "at"
+                      ],
+                      additionalProperties: false
+                    },
+                    capabilities: {
+                      type: "object",
+                      properties: {
+                        interruptible: {
+                          type: "boolean"
+                        },
+                        killable: {
+                          type: "boolean"
+                        },
+                        pausable: {
+                          type: "boolean"
+                        },
+                        resumable: {
+                          type: "boolean"
+                        },
+                        steerable: {
+                          type: "boolean"
+                        }
+                      },
+                      required: [
+                        "interruptible",
+                        "killable",
+                        "pausable",
+                        "resumable",
+                        "steerable"
+                      ],
+                      additionalProperties: false
+                    },
+                    sessionRef: {
+                      type: "object",
+                      properties: {
+                        sessionId: {
+                          type: "string"
+                        },
+                        agentId: {
+                          type: "string"
+                        }
+                      },
+                      additionalProperties: false
+                    }
+                  },
+                  required: [
+                    "id",
+                    "kind",
+                    "label",
+                    "state",
+                    "elapsedMs",
+                    "costState",
+                    "capabilities"
+                  ],
+                  additionalProperties: true
+                }
+              }
+            },
+            required: [
+              "capturedAt",
+              "nodes"
+            ],
+            additionalProperties: false
+          },
+          invokable: true
+        },
+        {
+          id: "fleet.archiveFinished",
+          title: "Archive All Finished Fleet Subtrees",
+          description: "Archive every root subtree whose nodes are all terminal (done/failed/killed/interrupted). A finished member of a still-running swarm stays with its parent. Returns the number of nodes archived.",
+          category: "fleet",
+          source: "builtin",
+          access: "authenticated",
+          transport: [
+            "ws"
+          ],
+          scopes: [
+            "write:fleet"
+          ],
+          inputSchema: {
+            type: "object",
+            properties: {},
+            additionalProperties: false
+          },
+          outputSchema: {
+            type: "object",
+            properties: {
+              archivedCount: {
+                type: "number"
+              }
+            },
+            required: [
+              "archivedCount"
+            ],
+            additionalProperties: false
+          },
+          invokable: true
+        },
         {
           id: "fleet.list",
           title: "List Fleet Processes",
@@ -291223,6 +291539,45 @@ var init_operator_contract = __esm(() => {
           },
           invokable: true
         },
+        {
+          id: "fleet.unarchive",
+          title: "Restore Archived Fleet Subtree",
+          description: "Return an archived subtree to the live fleet view. Returns the number of nodes restored (0 when nothing under the id was archived).",
+          category: "fleet",
+          source: "builtin",
+          access: "authenticated",
+          transport: [
+            "ws"
+          ],
+          scopes: [
+            "write:fleet"
+          ],
+          inputSchema: {
+            type: "object",
+            properties: {
+              id: {
+                type: "string"
+              }
+            },
+            required: [
+              "id"
+            ],
+            additionalProperties: false
+          },
+          outputSchema: {
+            type: "object",
+            properties: {
+              restored: {
+                type: "number"
+              }
+            },
+            required: [
+              "restored"
+            ],
+            additionalProperties: false
+          },
+          invokable: true
+        },
         {
           id: "health.snapshot",
           title: "Health Snapshot",
@@ -345715,10 +346070,10 @@ var init_operator_contract = __esm(() => {
         }
       ],
       schemaCoverage: {
-        methods: 329,
-        typedInputs: 329,
+        methods: 333,
+        typedInputs: 333,
         genericInputs: 0,
-        typedOutputs: 329,
+        typedOutputs: 333,
         genericOutputs: 0
       },
       eventCoverage: {
@@ -345727,8 +346082,8 @@ var init_operator_contract = __esm(() => {
         withWireEvents: 31
       },
       validationCoverage: {
-        methods: 329,
-        validated: 327,
+        methods: 333,
+        validated: 331,
         skippedGeneric: 0,
         skippedUntyped: 2
       }
@@ -345854,8 +346209,12 @@ var init_operator_method_ids = __esm(() => {
     "email.inbox.list",
     "email.inbox.read",
     "email.send",
+    "fleet.archive",
+    "fleet.archiveFinished",
+    "fleet.archived.list",
     "fleet.list",
     "fleet.snapshot",
+    "fleet.unarchive",
     "health.snapshot",
     "homeassistant.homeGraph.askHomeGraph",
     "homeassistant.homeGraph.browse",
@@ -348642,6 +349001,11 @@ var init_core_verbs = __esm(() => {
     "push-delivery": [
       "verify"
     ],
+    "fleet-archive": [
+      "archive",
+      "unarchive",
+      "archiveFinished"
+    ],
     "process-control": [
       "install",
       "restart",
@@ -365839,6 +366203,7 @@ ${priorTurnKnowledgeBlock}`;
           } catch (chatErr) {
             if (isContextSizeExceededError(chatErr) && !contextRetried && (context.featureFlagManager?.isEnabled("agent-context-window-awareness") ?? true)) {
               contextRetried = true;
+              context.providerRegistry.recordContextWindowRejection(`${activeRoute.provider.name}:${activeRoute.modelId}`, estimateConversationTokens(conversation.getMessagesForLLM()));
               logger.warn(`[AgentOrchestrator] context-window awareness: context size exceeded on turn ${turn2} - emergency compaction and retry`, { agentId: record2.id, error: chatErr instanceof Error ? chatErr.message : String(chatErr) });
               record2.progress = `Turn ${turn2} \xB7 Context exceeded, compacting\u2026`;
               context.emitAgentProgress(record2.id, record2.progress);
@@ -440036,7 +440401,7 @@ class ModelLimitsService {
     return this.resolveTokenLimits(modelDef);
   }
   getContextWindowForModel(modelDef) {
-    if ((modelDef.contextWindowProvenance === "provider_api" || modelDef.contextWindowProvenance === "configured_cap") && modelDef.contextWindow > 0) {
+    if ((modelDef.contextWindowProvenance === "provider_api" || modelDef.contextWindowProvenance === "configured_cap" || modelDef.contextWindowProvenance === "observed_limit") && modelDef.contextWindow > 0) {
       return modelDef.contextWindow;
     }
     const orMap = this.ensureOpenRouterMap();
@@ -440116,86 +440481,134 @@ function getContextWindowOverridesPath(configDir) {
 function isValidContextWindowOverride(value) {
   return Number.isInteger(value) && value > 0 && value <= MAX_CONTEXT_WINDOW_OVERRIDE;
 }
+function readValidEntries(source, label) {
+  const map5 = new Map;
+  for (const [registryKey, value] of Object.entries(source ?? {})) {
+    if (typeof value === "number" && isValidContextWindowOverride(value)) {
+      map5.set(registryKey, value);
+    } else {
+      logger.warn(`[context-window-overrides] Dropping invalid ${label} entry`, { registryKey, value });
+    }
+  }
+  return map5;
+}
 function loadContextWindowOverrides(filePath) {
-  const overrides = new Map;
+  const empty = { overrides: new Map, observed: new Map };
   let raw;
   try {
     raw = readFileSync48(filePath, "utf-8");
   } catch {
-    return overrides;
+    return empty;
   }
   try {
     const parsed = JSON.parse(raw);
-    if (!parsed || parsed.version !== 1 || typeof parsed.overrides !== "object" || parsed.overrides === null) {
+    if (!parsed || parsed.version !== 1 && parsed.version !== 2 || typeof parsed.overrides !== "object" || parsed.overrides === null) {
       logger.warn("[context-window-overrides] Ignoring malformed overrides file", { filePath });
-      return overrides;
-    }
-    for (const [registryKey, value] of Object.entries(parsed.overrides)) {
-      if (typeof value === "number" && isValidContextWindowOverride(value)) {
-        overrides.set(registryKey, value);
-      } else {
-        logger.warn("[context-window-overrides] Dropping invalid override entry", { registryKey, value });
-      }
+      return empty;
     }
+    return {
+      overrides: readValidEntries(parsed.overrides, "override"),
+      observed: readValidEntries(parsed.observed, "observed-limit")
+    };
   } catch (error51) {
     logger.warn("[context-window-overrides] Failed to parse overrides file", {
       filePath,
       error: summarizeError(error51)
     });
+    return empty;
+  }
+}
+function saveContextWindowOverrides(filePath, state) {
+  const sorted2 = (map5) => Object.fromEntries([...map5.entries()].sort(([a2], [b2]) => a2.localeCompare(b2)));
+  const file2 = {
+    version: 2,
+    overrides: sorted2(state.overrides),
+    observed: sorted2(state.observed)
+  };
+  try {
+    mkdirSync33(dirname37(filePath), { recursive: true });
+    writeFileSync29(filePath, `${JSON.stringify(file2, null, 2)}
+`, "utf-8");
+  } catch (error51) {
+    logger.warn("[context-window-overrides] Failed to persist overrides", {
+      filePath,
+      error: summarizeError(error51)
+    });
   }
-  return overrides;
 }
 
 class ContextWindowOverrideStore {
   filePath;
-  overrides = null;
+  state = null;
   constructor(filePath) {
     this.filePath = filePath;
   }
   load() {
-    this.overrides ??= loadContextWindowOverrides(this.filePath);
-    return this.overrides;
+    this.state ??= loadContextWindowOverrides(this.filePath);
+    return this.state;
+  }
+  persist() {
+    saveContextWindowOverrides(this.filePath, this.load());
   }
   get(registryKey) {
-    return this.load().get(registryKey) ?? null;
+    return this.load().overrides.get(registryKey) ?? null;
+  }
+  getObserved(registryKey) {
+    return this.load().observed.get(registryKey) ?? null;
   }
   set(registryKey, cap) {
     if (!isValidContextWindowOverride(cap))
       return false;
-    const overrides = this.load();
-    overrides.set(registryKey, cap);
-    saveContextWindowOverrides(this.filePath, overrides);
+    this.load().overrides.set(registryKey, cap);
+    this.persist();
     return true;
   }
   clear(registryKey) {
-    const overrides = this.load();
-    const existed = overrides.delete(registryKey);
-    if (existed)
-      saveContextWindowOverrides(this.filePath, overrides);
-    return existed;
-  }
-  apply(model) {
-    const override = this.load().get(model.registryKey);
-    if (override === undefined)
-      return model;
-    return { ...model, contextWindow: override, contextWindowProvenance: "configured_cap" };
+    const state = this.load();
+    const existed = state.overrides.delete(registryKey);
+    const observedExisted = state.observed.delete(registryKey);
+    if (existed || observedExisted)
+      this.persist();
+    return existed || observedExisted;
   }
-}
-function saveContextWindowOverrides(filePath, overrides) {
-  const file2 = {
-    version: 1,
-    overrides: Object.fromEntries([...overrides.entries()].sort(([a2], [b2]) => a2.localeCompare(b2)))
-  };
-  try {
-    mkdirSync33(dirname37(filePath), { recursive: true });
-    writeFileSync29(filePath, `${JSON.stringify(file2, null, 2)}
-`, "utf-8");
-  } catch (error51) {
-    logger.warn("[context-window-overrides] Failed to persist overrides", {
-      filePath,
-      error: summarizeError(error51)
+  recordRejection(registryKey, rejectedAtTokens) {
+    const rounded = Math.floor(rejectedAtTokens);
+    if (!isValidContextWindowOverride(rounded))
+      return;
+    const state = this.load();
+    const existing = state.observed.get(registryKey);
+    if (existing !== undefined && existing <= rounded)
+      return;
+    state.observed.set(registryKey, rounded);
+    this.persist();
+    logger.info("[context-window-overrides] Learned context ceiling from provider rejection", {
+      registryKey,
+      observedTokens: rounded
     });
   }
+  reconcileSuccess(registryKey, successfulInputTokens) {
+    const rounded = Math.floor(successfulInputTokens);
+    const state = this.load();
+    const existing = state.observed.get(registryKey);
+    if (existing === undefined || rounded <= existing)
+      return;
+    if (!isValidContextWindowOverride(rounded))
+      return;
+    state.observed.set(registryKey, rounded);
+    this.persist();
+  }
+  apply(model) {
+    const state = this.load();
+    const override = state.overrides.get(model.registryKey);
+    if (override !== undefined) {
+      return { ...model, contextWindow: override, contextWindowProvenance: "configured_cap" };
+    }
+    const observed = state.observed.get(model.registryKey);
+    if (observed !== undefined && (model.contextWindow <= 0 || observed < model.contextWindow)) {
+      return { ...model, contextWindow: observed, contextWindowProvenance: "observed_limit" };
+    }
+    return model;
+  }
 }
 var MAX_CONTEXT_WINDOW_OVERRIDE = 1e7;
 var init_context_window_overrides = __esm(() => {
@@ -440630,6 +441043,20 @@ class ProviderRegistry {
   getModelContextCap(registryKey) {
     return this.contextWindowOverrideStore().get(registryKey);
   }
+  getObservedContextWindow(registryKey) {
+    return this.contextWindowOverrideStore().getObserved(registryKey);
+  }
+  recordContextWindowRejection(registryKey, rejectedAtTokens) {
+    this.contextWindowOverrideStore().recordRejection(registryKey, rejectedAtTokens);
+    this._invalidateModelRegistry();
+  }
+  reconcileObservedContextWindow(registryKey, successfulInputTokens) {
+    const before = this.contextWindowOverrideStore().getObserved(registryKey);
+    if (before === null || successfulInputTokens <= before)
+      return;
+    this.contextWindowOverrideStore().reconcileSuccess(registryKey, successfulInputTokens);
+    this._invalidateModelRegistry();
+  }
   setCurrentModel(registryKey) {
     if (!registryKey.includes(":")) {
       throw new Error(`Model selection requires a provider-qualified registryKey; received '${registryKey}'.`);
@@ -451451,7 +451878,7 @@ var init_operator_contract_schemas_runtime = __esm(() => {
 });
 
 // node_modules/@pellux/goodvibes-sdk/dist/platform/control-plane/operator-contract-schemas-fleet.js
-var PROCESS_KIND_SCHEMA, PROCESS_STATE_SCHEMA, PROCESS_COST_STATE_SCHEMA, PROCESS_USAGE_SCHEMA, PROCESS_ACTIVITY_SCHEMA, PROCESS_CAPABILITIES_SCHEMA, PROCESS_SESSION_REF_SCHEMA, PROCESS_NODE_SCHEMA, FLEET_SNAPSHOT_OUTPUT_SCHEMA, FLEET_LIST_INPUT_SCHEMA, FLEET_LIST_OUTPUT_SCHEMA, CHECKPOINT_KIND_SCHEMA, RETENTION_CLASS_SCHEMA, WORKSPACE_CHECKPOINT_SCHEMA, CHECKPOINTS_LIST_INPUT_SCHEMA, CHECKPOINTS_LIST_OUTPUT_SCHEMA, CHECKPOINTS_CREATE_INPUT_SCHEMA, CHECKPOINTS_CREATE_OUTPUT_SCHEMA, CHECKPOINT_DIFF_SCHEMA, CHECKPOINTS_DIFF_INPUT_SCHEMA, CHECKPOINTS_DIFF_OUTPUT_SCHEMA, CHECKPOINT_RESTORE_RESULT_SCHEMA, CHECKPOINTS_RESTORE_INPUT_SCHEMA, CHECKPOINTS_RESTORE_OUTPUT_SCHEMA, SESSIONS_SEARCH_INPUT_SCHEMA, SESSIONS_SEARCH_OUTPUT_SCHEMA;
+var PROCESS_KIND_SCHEMA, PROCESS_STATE_SCHEMA, PROCESS_COST_STATE_SCHEMA, PROCESS_USAGE_SCHEMA, PROCESS_ACTIVITY_SCHEMA, PROCESS_CAPABILITIES_SCHEMA, PROCESS_SESSION_REF_SCHEMA, PROCESS_NODE_SCHEMA, FLEET_SNAPSHOT_OUTPUT_SCHEMA, FLEET_LIST_INPUT_SCHEMA, FLEET_LIST_OUTPUT_SCHEMA, FLEET_ARCHIVE_INPUT_SCHEMA, FLEET_ARCHIVE_OUTPUT_SCHEMA, FLEET_UNARCHIVE_OUTPUT_SCHEMA, FLEET_ARCHIVE_FINISHED_OUTPUT_SCHEMA, FLEET_ARCHIVED_LIST_OUTPUT_SCHEMA, CHECKPOINT_KIND_SCHEMA, RETENTION_CLASS_SCHEMA, WORKSPACE_CHECKPOINT_SCHEMA, CHECKPOINTS_LIST_INPUT_SCHEMA, CHECKPOINTS_LIST_OUTPUT_SCHEMA, CHECKPOINTS_CREATE_INPUT_SCHEMA, CHECKPOINTS_CREATE_OUTPUT_SCHEMA, CHECKPOINT_DIFF_SCHEMA, CHECKPOINTS_DIFF_INPUT_SCHEMA, CHECKPOINTS_DIFF_OUTPUT_SCHEMA, CHECKPOINT_RESTORE_RESULT_SCHEMA, CHECKPOINTS_RESTORE_INPUT_SCHEMA, CHECKPOINTS_RESTORE_OUTPUT_SCHEMA, SESSIONS_SEARCH_INPUT_SCHEMA, SESSIONS_SEARCH_OUTPUT_SCHEMA;
 var init_operator_contract_schemas_fleet = __esm(() => {
   init_method_catalog_shared();
   init_operator_contract_schemas_shared();
@@ -451550,6 +451977,24 @@ var init_operator_contract_schemas_fleet = __esm(() => {
     hasMore: BOOLEAN_SCHEMA,
     capturedAt: NUMBER_SCHEMA
   }, ["items", "hasMore", "capturedAt"]);
+  FLEET_ARCHIVE_INPUT_SCHEMA = objectSchema({
+    id: STRING_SCHEMA
+  }, ["id"]);
+  FLEET_ARCHIVE_OUTPUT_SCHEMA = objectSchema({
+    archived: BOOLEAN_SCHEMA,
+    count: NUMBER_SCHEMA,
+    reason: STRING_SCHEMA
+  }, ["archived", "count"]);
+  FLEET_UNARCHIVE_OUTPUT_SCHEMA = objectSchema({
+    restored: NUMBER_SCHEMA
+  }, ["restored"]);
+  FLEET_ARCHIVE_FINISHED_OUTPUT_SCHEMA = objectSchema({
+    archivedCount: NUMBER_SCHEMA
+  }, ["archivedCount"]);
+  FLEET_ARCHIVED_LIST_OUTPUT_SCHEMA = objectSchema({
+    capturedAt: NUMBER_SCHEMA,
+    nodes: arraySchema(PROCESS_NODE_SCHEMA)
+  }, ["capturedAt", "nodes"]);
   CHECKPOINT_KIND_SCHEMA = enumSchema(["turn", "agent-run", "manual"]);
   RETENTION_CLASS_SCHEMA = enumSchema(["short", "standard", "forensic"]);
   WORKSPACE_CHECKPOINT_SCHEMA = objectSchema({
@@ -454835,6 +455280,46 @@ var init_method_catalog_fleet = __esm(() => {
       inputSchema: FLEET_LIST_INPUT_SCHEMA,
       outputSchema: FLEET_LIST_OUTPUT_SCHEMA
     }),
+    methodDescriptor({
+      id: "fleet.archive",
+      title: "Archive Finished Fleet Subtree",
+      description: "Move one FINISHED process subtree (root id + all descendants, every node terminal) out of the live fleet view into the session archive. Honest refusal (archived:false + reason) for an unknown id or a subtree with live members. Archived nodes stay inspectable via fleet.archived.list.",
+      category: "fleet",
+      scopes: ["write:fleet"],
+      transport: ["ws"],
+      inputSchema: FLEET_ARCHIVE_INPUT_SCHEMA,
+      outputSchema: FLEET_ARCHIVE_OUTPUT_SCHEMA
+    }),
+    methodDescriptor({
+      id: "fleet.unarchive",
+      title: "Restore Archived Fleet Subtree",
+      description: "Return an archived subtree to the live fleet view. Returns the number of nodes restored (0 when nothing under the id was archived).",
+      category: "fleet",
+      scopes: ["write:fleet"],
+      transport: ["ws"],
+      inputSchema: FLEET_ARCHIVE_INPUT_SCHEMA,
+      outputSchema: FLEET_UNARCHIVE_OUTPUT_SCHEMA
+    }),
+    methodDescriptor({
+      id: "fleet.archiveFinished",
+      title: "Archive All Finished Fleet Subtrees",
+      description: "Archive every root subtree whose nodes are all terminal (done/failed/killed/interrupted). A finished member of a still-running swarm stays with its parent. Returns the number of nodes archived.",
+      category: "fleet",
+      scopes: ["write:fleet"],
+      transport: ["ws"],
+      inputSchema: EMPTY_OBJECT_SCHEMA,
+      outputSchema: FLEET_ARCHIVE_FINISHED_OUTPUT_SCHEMA
+    }),
+    methodDescriptor({
+      id: "fleet.archived.list",
+      title: "List Archived Fleet Processes",
+      description: "Return the session-archived process nodes (same node shape as fleet.snapshot; still live-derived from the source managers, so usage/cost stay current).",
+      category: "fleet",
+      scopes: ["read:fleet"],
+      transport: ["ws"],
+      inputSchema: EMPTY_OBJECT_SCHEMA,
+      outputSchema: FLEET_ARCHIVED_LIST_OUTPUT_SCHEMA
+    }),
     methodDescriptor({
       id: "checkpoints.list",
       title: "List Workspace Checkpoints",
@@ -460549,15 +461034,52 @@ function createFleetListHandler(registry3) {
     };
   };
 }
-function registerFleetGatewayMethods(catalog, registry3) {
-  const snapshotDescriptor = catalog.get("fleet.snapshot");
-  if (snapshotDescriptor) {
-    catalog.register(snapshotDescriptor, createFleetSnapshotHandler(registry3), { replace: true });
-  }
-  const listDescriptor = catalog.get("fleet.list");
-  if (listDescriptor) {
-    catalog.register(listDescriptor, createFleetListHandler(registry3), { replace: true });
+function requireArchive(registry3, method) {
+  const fn = registry3[method];
+  if (!fn) {
+    throw new GatewayVerbError("This runtime has no fleet archive layer.", "UNSUPPORTED", 501);
   }
+  return fn;
+}
+function createFleetArchiveHandler(registry3) {
+  return (invocation) => {
+    const params = readInvocationParams(invocation);
+    const id = typeof params.id === "string" ? params.id.trim() : "";
+    if (!id)
+      throw new GatewayVerbError("id is required", "INVALID_ARGUMENT", 400);
+    return requireArchive(registry3, "archive")(id);
+  };
+}
+function createFleetUnarchiveHandler(registry3) {
+  return (invocation) => {
+    const params = readInvocationParams(invocation);
+    const id = typeof params.id === "string" ? params.id.trim() : "";
+    if (!id)
+      throw new GatewayVerbError("id is required", "INVALID_ARGUMENT", 400);
+    return { restored: requireArchive(registry3, "unarchive")(id) };
+  };
+}
+function createFleetArchiveFinishedHandler(registry3) {
+  return () => ({ archivedCount: requireArchive(registry3, "archiveFinished")() });
+}
+function createFleetArchivedListHandler(registry3) {
+  return () => {
+    const snapshot = requireArchive(registry3, "listArchived")();
+    return { capturedAt: snapshot.capturedAt, nodes: snapshot.nodes };
+  };
+}
+function registerFleetGatewayMethods(catalog, registry3) {
+  const attach = (id, handler) => {
+    const descriptor = catalog.get(id);
+    if (descriptor)
+      catalog.register(descriptor, handler, { replace: true });
+  };
+  attach("fleet.snapshot", createFleetSnapshotHandler(registry3));
+  attach("fleet.list", createFleetListHandler(registry3));
+  attach("fleet.archive", createFleetArchiveHandler(registry3));
+  attach("fleet.unarchive", createFleetUnarchiveHandler(registry3));
+  attach("fleet.archiveFinished", createFleetArchiveFinishedHandler(registry3));
+  attach("fleet.archived.list", createFleetArchivedListHandler(registry3));
 }
 var FLEET_SNAPSHOT_NODE_CAP = 2000, FLEET_LIST_DEFAULT_LIMIT = 100, FLEET_LIST_MAX_LIMIT = 500, PROCESS_KINDS, PROCESS_STATES;
 var init_fleet = __esm(() => {
@@ -464738,6 +465260,23 @@ function createSchema2(db) {
     )
   `);
 }
+function getKnowledgeSchemaStatements() {
+  const statements = [];
+  createSchema2({
+    run(sql) {
+      const normalized = sql.trim();
+      if (normalized.length > 0)
+        statements.push(normalized);
+    }
+  });
+  return statements;
+}
+function renderKnowledgeSchemaSql() {
+  return `${getKnowledgeSchemaStatements().map((statement) => statement.endsWith(";") ? statement : `${statement};`).join(`
+
+`)}
+`;
+}
 function rowObject(columns, values2) {
   return Object.fromEntries(columns.map((column, index) => [column, values2[index]]));
 }
@@ -778110,6 +778649,9 @@ var init_ingest = __esm(() => {
 // node_modules/@pellux/goodvibes-sdk/dist/platform/knowledge/browser-history/index.js
 var init_browser_history = __esm(() => {
   init_ingest();
+  init_discover();
+  init_readers();
+  init_paths2();
 });
 
 // node_modules/graphql/jsutils/devAssert.mjs
@@ -795984,6 +796526,7 @@ var init_semantic = __esm(() => {
   init_llm();
   init_gap_repair();
   init_service5();
+  init_self_improvement();
 });
 
 // node_modules/@pellux/goodvibes-sdk/dist/platform/knowledge/home-graph/helpers.js
@@ -799952,8 +800495,40 @@ var init_map_view = __esm(() => {
 });
 
 // node_modules/@pellux/goodvibes-sdk/dist/platform/knowledge/home-graph/types.js
-var HOME_GRAPH_CAPABILITIES;
+var HOME_GRAPH_NODE_KINDS, HOME_GRAPH_RELATIONS, HOME_GRAPH_CAPABILITIES;
 var init_types15 = __esm(() => {
+  HOME_GRAPH_NODE_KINDS = [
+    "ha_home",
+    "ha_entity",
+    "ha_device",
+    "ha_area",
+    "ha_automation",
+    "ha_script",
+    "ha_scene",
+    "ha_label",
+    "ha_integration",
+    "ha_room",
+    "ha_device_passport",
+    "ha_maintenance_item",
+    "ha_troubleshooting_case",
+    "ha_purchase",
+    "ha_network_node"
+  ];
+  HOME_GRAPH_RELATIONS = [
+    "controls",
+    "located_in",
+    "belongs_to_device",
+    "has_manual",
+    "has_receipt",
+    "has_warranty",
+    "has_issue",
+    "fixed_by",
+    "uses_battery",
+    "connected_via",
+    "part_of_network",
+    "mentioned_by",
+    "source_for"
+  ];
   HOME_GRAPH_CAPABILITIES = [
     "knowledge-space-isolation",
     "snapshot-sync",
@@ -801744,6 +802319,7 @@ var init_service6 = __esm(() => {
 var init_home_graph = __esm(() => {
   init_service6();
   init_extension();
+  init_types15();
 });
 
 // node_modules/@pellux/goodvibes-sdk/dist/platform/knowledge/store-record-delete.js
@@ -804168,10 +804744,14 @@ var init_service7 = __esm(() => {
 var init_project_planning = __esm(() => {
   init_service7();
   init_helpers3();
+  init_readiness();
 });
 
 // node_modules/@pellux/goodvibes-sdk/dist/platform/knowledge/persistence.js
-var init_persistence = () => {};
+var init_persistence = __esm(() => {
+  init_store_schema();
+  init_store_load();
+});
 
 // node_modules/@pellux/goodvibes-sdk/dist/platform/knowledge/projections.js
 class KnowledgeProjectionService {
@@ -807725,21 +808305,21 @@ var init_service8 = __esm(() => {
 var exports_knowledge = {};
 __export(exports_knowledge, {
   withKnowledgeSpace: () => withKnowledgeSpace,
-  uniqKnowledgeValues: () => uniq3,
-  stabilizeKnowledgeText: () => stableText2,
-  runKnowledgeSemanticSelfImprovement: () => runKnowledgeSemanticSelfImprovement2,
+  uniqKnowledgeValues: () => uniq2,
+  stabilizeKnowledgeText: () => stableText,
+  runKnowledgeSemanticSelfImprovement: () => runKnowledgeSemanticSelfImprovement,
   resolveProjectPlanningSpace: () => resolveProjectPlanningSpace,
-  resolveKnowledgeDbPathFromControlPlaneDir: () => resolveKnowledgeDbPathFromControlPlaneDir2,
+  resolveKnowledgeDbPathFromControlPlaneDir: () => resolveKnowledgeDbPathFromControlPlaneDir,
   renderPacket: () => renderPacket,
   renderKnowledgeSchemaSql: () => renderKnowledgeSchemaSql,
   renderKnowledgeMap: () => renderKnowledgeMap,
   readKnowledgeSearchText: () => readKnowledgeSearchText,
-  readBrowserKnowledgeProfile: () => readBrowserKnowledgeProfile2,
+  readBrowserKnowledgeProfile: () => readBrowserKnowledgeProfile,
   projectPlanningSourceId: () => projectPlanningSourceId,
   projectPlanningProjectIdFromPath: () => projectPlanningProjectIdFromPath,
   projectPlanningCanonicalUri: () => projectPlanningCanonicalUri,
   projectKnowledgeSpaceId: () => projectKnowledgeSpaceId,
-  parseKnowledgeJsonValue: () => parseJsonValue2,
+  parseKnowledgeJsonValue: () => parseJsonValue,
   normalizeProjectId: () => normalizeProjectId,
   normalizeKnowledgeSpaceId: () => normalizeKnowledgeSpaceId,
   normalizeHomeAssistantInstallationId: () => normalizeHomeAssistantInstallationId,
@@ -807747,12 +808327,12 @@ __export(exports_knowledge, {
   materializeGeneratedKnowledgeProjection: () => materializeGeneratedKnowledgeProjection,
   looksLikeRawPdfPayload: () => looksLikeRawPdfPayload,
   looksBinaryLikeText: () => looksBinaryLikeText,
-  loadKnowledgeStoreSnapshot: () => loadKnowledgeStoreSnapshot2,
+  loadKnowledgeStoreSnapshot: () => loadKnowledgeStoreSnapshot,
   listGeneratedKnowledgePages: () => listGeneratedKnowledgePages,
-  listBrowserKinds: () => listBrowserKinds2,
+  listBrowserKinds: () => listBrowserKinds,
   knowledgeSpaceMetadata: () => knowledgeSpaceMetadata,
   knowledgePageSourceWeight: () => knowledgePageSourceWeight,
-  knowledgeNowMs: () => nowMs2,
+  knowledgeNowMs: () => nowMs,
   knowledgeExtractionNeedsRefresh: () => knowledgeExtractionNeedsRefresh,
   isUsefulKnowledgePageSourceCandidate: () => isUsefulKnowledgePageSourceCandidate,
   isUsefulKnowledgePageSource: () => isUsefulKnowledgePageSource,
@@ -807772,12 +808352,12 @@ __export(exports_knowledge, {
   generatedKnowledgeSourceId: () => generatedKnowledgeSourceId,
   generatedKnowledgeCanonicalUri: () => generatedKnowledgeCanonicalUri,
   extractKnowledgeArtifact: () => extractKnowledgeArtifact,
-  evaluateProjectPlanningReadiness: () => evaluateProjectPlanningReadiness2,
-  discoverBrowserKnowledgeProfiles: () => discoverBrowserKnowledgeProfiles2,
+  evaluateProjectPlanningReadiness: () => evaluateProjectPlanningReadiness,
+  discoverBrowserKnowledgeProfiles: () => discoverBrowserKnowledgeProfiles,
   createWebKnowledgeGapRepairer: () => createWebKnowledgeGapRepairer,
   createProviderBackedKnowledgeSemanticLlm: () => createProviderBackedKnowledgeSemanticLlm,
   createMemoryApi: () => createMemoryApi,
-  createKnowledgeSchema: () => createSchema3,
+  createKnowledgeSchema: () => createSchema2,
   createKnowledgeApi: () => createKnowledgeApi,
   createDefaultKnowledgeConnectorRegistry: () => createDefaultKnowledgeConnectorRegistry,
   compareKnowledgePageSources: () => compareKnowledgePageSources,
@@ -810250,7 +810830,7 @@ var init_delivery_manager = __esm(() => {
 });
 
 // node_modules/@pellux/goodvibes-sdk/dist/platform/automation/scheduler-capacity.js
-function computeSchedulerCapacity(slotsTotal, runs, nowMs3 = Date.now()) {
+function computeSchedulerCapacity(slotsTotal, runs, nowMs2 = Date.now()) {
   let slotsInUse = 0;
   const queuedRuns = [];
   for (const run7 of runs) {
@@ -810260,7 +810840,7 @@ function computeSchedulerCapacity(slotsTotal, runs, nowMs3 = Date.now()) {
       queuedRuns.push(run7);
   }
   const queueDepth = queuedRuns.length;
-  const oldestQueuedAgeMs = queueDepth > 0 ? nowMs3 - Math.min(...queuedRuns.map((r6) => r6.queuedAt)) : null;
+  const oldestQueuedAgeMs = queueDepth > 0 ? nowMs2 - Math.min(...queuedRuns.map((r6) => r6.queuedAt)) : null;
   return { slotsTotal, slotsInUse, queueDepth, oldestQueuedAgeMs };
 }
 
@@ -831868,9 +832448,145 @@ var init_registry8 = __esm(() => {
   };
 });
 
+// node_modules/@pellux/goodvibes-sdk/dist/platform/runtime/fleet/archive.js
+function collectSubtreeIds(rootId, nodes) {
+  const childrenByParent = new Map;
+  for (const node of nodes) {
+    if (node.parentId === undefined)
+      continue;
+    const siblings = childrenByParent.get(node.parentId);
+    if (siblings)
+      siblings.push(node);
+    else
+      childrenByParent.set(node.parentId, [node]);
+  }
+  const ids = [];
+  const stack = [rootId];
+  const seen = new Set;
+  while (stack.length > 0) {
+    const id = stack.pop();
+    if (seen.has(id))
+      continue;
+    seen.add(id);
+    ids.push(id);
+    for (const child of childrenByParent.get(id) ?? [])
+      stack.push(child.id);
+  }
+  return ids;
+}
+function withFleetArchive(registry3) {
+  const archivedIds = new Set;
+  const listeners = new Set;
+  let underlyingUnsub = null;
+  const filterSnapshot = (snapshot) => ({
+    capturedAt: snapshot.capturedAt,
+    nodes: snapshot.nodes.filter((node) => !archivedIds.has(node.id))
+  });
+  const notifyAll = () => {
+    const snapshot = filterSnapshot(registry3.query());
+    for (const listener of listeners)
+      listener(snapshot);
+  };
+  const archiveSubtree = (rootId, nodes) => {
+    const root = nodes.find((node) => node.id === rootId);
+    if (!root)
+      return { archived: false, count: 0, reason: `node ${rootId} not found` };
+    const subtreeIds = collectSubtreeIds(rootId, nodes);
+    const subtreeNodes = nodes.filter((node) => subtreeIds.includes(node.id));
+    const live = subtreeNodes.filter((node) => !ARCHIVE_TERMINAL_STATES.has(node.state));
+    if (live.length > 0) {
+      return {
+        archived: false,
+        count: 0,
+        reason: `${live.length} node(s) in the subtree are still active (${live[0].state}) \u2014 only finished subtrees can be archived`
+      };
+    }
+    for (const id of subtreeIds)
+      archivedIds.add(id);
+    return { archived: true, count: subtreeIds.length };
+  };
+  return {
+    ...registry3,
+    query(filter) {
+      return filterSnapshot(registry3.query(filter));
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      underlyingUnsub ??= registry3.subscribe(() => {
+        notifyAll();
+      });
+      return () => {
+        listeners.delete(listener);
+        if (listeners.size === 0 && underlyingUnsub) {
+          underlyingUnsub();
+          underlyingUnsub = null;
+        }
+      };
+    },
+    archive(id) {
+      const result = archiveSubtree(id, registry3.query().nodes);
+      if (result.archived)
+        notifyAll();
+      return result;
+    },
+    unarchive(id) {
+      const subtreeIds = collectSubtreeIds(id, registry3.query().nodes);
+      let released = 0;
+      for (const subtreeId of subtreeIds) {
+        if (archivedIds.delete(subtreeId))
+          released++;
+      }
+      if (released > 0)
+        notifyAll();
+      return released;
+    },
+    archiveFinished() {
+      const nodes = registry3.query().nodes;
+      const present = new Set(nodes.map((node) => node.id));
+      let archivedNodes = 0;
+      for (const node of nodes) {
+        if (archivedIds.has(node.id))
+          continue;
+        const isRoot = node.parentId === undefined || !present.has(node.parentId);
+        if (!isRoot || !ARCHIVE_TERMINAL_STATES.has(node.state))
+          continue;
+        const result = archiveSubtree(node.id, nodes);
+        if (result.archived)
+          archivedNodes += result.count;
+      }
+      if (archivedNodes > 0)
+        notifyAll();
+      return archivedNodes;
+    },
+    listArchived() {
+      const snapshot = registry3.query();
+      return {
+        capturedAt: snapshot.capturedAt,
+        nodes: snapshot.nodes.filter((node) => archivedIds.has(node.id))
+      };
+    },
+    archivedCount() {
+      return archivedIds.size;
+    },
+    dispose() {
+      listeners.clear();
+      if (underlyingUnsub) {
+        underlyingUnsub();
+        underlyingUnsub = null;
+      }
+      registry3.dispose();
+    }
+  };
+}
+var ARCHIVE_TERMINAL_STATES;
+var init_archive = __esm(() => {
+  ARCHIVE_TERMINAL_STATES = new Set(["done", "failed", "killed", "interrupted"]);
+});
+
 // node_modules/@pellux/goodvibes-sdk/dist/platform/runtime/fleet/index.js
 var init_fleet2 = __esm(() => {
   init_registry8();
+  init_archive();
 });
 
 // node_modules/@pellux/goodvibes-sdk/dist/platform/orchestration/budget.js
@@ -833592,7 +834308,7 @@ function createRuntimeServices(options) {
     projectRoot: workingDirectory,
     priceUsage
   });
-  const processRegistry = createProcessRegistry({
+  const processRegistry = withFleetArchive(createProcessRegistry({
     agentManager,
     wrfcController,
     orchestrationEngine,
@@ -833608,7 +834324,7 @@ function createRuntimeServices(options) {
     runtimeBus: options.runtimeBus,
     priceUsage,
     codeIndexService: codeIndexStore
-  });
+  }));
   registerGatewayVerbGroups(gatewayMethods, { processRegistry, workspaceCheckpointManager, sessionBroker, secretsManager, approvalBroker, shellPaths });
   return {
     workingDirectory,
@@ -837756,7 +838472,7 @@ var createStyledCell = (char, overrides = {}) => ({
 // src/version.ts
 import { readFileSync } from "fs";
 import { join } from "path";
-var _version = "1.7.0";
+var _version = "1.8.1";
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, "..", "package.json"), "utf-8"));
   _version = typeof pkg.version === "string" ? pkg.version : _version;
@@ -839872,6 +840588,7 @@ async function executeOrchestratorTurnLoop(context) {
   const toolDefinitions = context.toolRegistry.getToolDefinitions();
   const streamEnabled = context.configManager.get("display.stream");
   let continueLoop = true;
+  let contextOverflowRetried = false;
   const circuitBreaker = new ConsecutiveErrorBreaker;
   let isFirstIterationOfThisCall = true;
   let turnKnowledgeBlock = null;
@@ -840065,6 +840782,19 @@ ${turnKnowledgeBlock}`;
       if (streamSessionStarted && context.runtimeBus) {
         emitStreamEnd(context.runtimeBus, context.emitterContext(context.turnId), { turnId: context.turnId });
       }
+      if (isContextSizeExceededError(chatErr) && !contextOverflowRetried) {
+        contextOverflowRetried = true;
+        const rejectedAtTokens = estimateConversationTokens(context.conversation.getMessagesForLLM());
+        context.providerRegistry.recordContextWindowRejection(model.registryKey, rejectedAtTokens);
+        context.noteModelContextWindowWarning({
+          provider: model.provider,
+          model: model.id,
+          providerStopReason: "context_length_exceeded (provider error)"
+        });
+        context.conversation.addSystemMessage(`${model.displayName} rejected the request as exceeding its context window (~${rejectedAtTokens.toLocaleString()} tokens sent). Learned this as the model's practical limit. Auto-compacting and retrying...`);
+        context.requestRender();
+        continue;
+      }
       if (chatErr instanceof ProviderError && chatErr.statusCode === 429 && model.provider === "synthetic" && model.tier !== "free") {
         context.conversation.addSystemMessage(`All providers for ${model.displayName} are currently exhausted.
 ` + `Options:
@@ -840139,7 +840869,9 @@ ${turnKnowledgeBlock}`;
       logger.info(`[Cache] Low hit rate: ${(cacheMetrics.hitRate * 100).toFixed(0)}% over ${cacheMetrics.turns} turns`);
     }
     context.setLastRequestInputTokens(response.usage.inputTokens);
-    context.setLastInputTokens(response.usage.inputTokens + (response.usage.cacheReadTokens ?? 0) + (response.usage.cacheWriteTokens ?? 0));
+    const realInputTokens = response.usage.inputTokens + (response.usage.cacheReadTokens ?? 0) + (response.usage.cacheWriteTokens ?? 0);
+    context.setLastInputTokens(realInputTokens);
+    context.providerRegistry.reconcileObservedContextWindow(model.registryKey, realInputTokens);
     if (context.runtimeBus) {
       emitLlmResponseReceived(context.runtimeBus, context.emitterContext(context.turnId), {
         turnId: context.turnId,
@@ -840776,6 +841508,9 @@ class Orchestrator {
           this.conversation.addSystemMessage(msg);
         }
       }
+      for (const event of eventsToReplay) {
+        this.replayQueue.acknowledge(event.id);
+      }
       this.requestRender();
     }
     this.followUpRuntime.scheduleFlush();
@@ -862945,7 +863680,7 @@ var WORK_PLAN_STATUSES = [
   "failed",
   "cancelled"
 ];
-function nowMs3() {
+function nowMs2() {
   return Date.now();
 }
 function isObject4(value) {
@@ -863051,7 +863786,7 @@ class WorkPlanStore {
     if (!normalizedTitle)
       throw new Error("Work plan item title is required.");
     const plan = this.readPlan();
-    const time4 = nowMs3();
+    const time4 = nowMs2();
     const item = {
       id: createItemId(),
       title: normalizedTitle,
@@ -863075,7 +863810,7 @@ class WorkPlanStore {
   updateItem(idOrPrefix, patch2) {
     const plan = this.readPlan();
     const item = this.resolveItem(plan, idOrPrefix);
-    const time4 = nowMs3();
+    const time4 = nowMs2();
     const nextStatus = patch2.status ?? item.status;
     const next = this.pruneItem({
       ...item,
@@ -863108,7 +863843,7 @@ class WorkPlanStore {
   removeItem(idOrPrefix) {
     const plan = this.readPlan();
     const item = this.resolveItem(plan, idOrPrefix);
-    const time4 = nowMs3();
+    const time4 = nowMs2();
     const remaining = plan.items.filter((candidate) => candidate.id !== item.id);
     this.writePlan({
       ...plan,
@@ -863128,7 +863863,7 @@ class WorkPlanStore {
       ...plan,
       items: remaining,
       activeItemId: remaining[0]?.id,
-      updatedAt: nowMs3()
+      updatedAt: nowMs2()
     });
     return removed;
   }
@@ -863167,7 +863902,7 @@ class WorkPlanStore {
     const parsed = JSON.parse(raw);
     if (!isObject4(parsed))
       return this.createEmptyPlan();
-    const time4 = nowMs3();
+    const time4 = nowMs2();
     const createdAt = typeof parsed.createdAt === "number" ? parsed.createdAt : time4;
     const updatedAt = typeof parsed.updatedAt === "number" ? parsed.updatedAt : createdAt;
     const items = Array.isArray(parsed.items) ? parsed.items.map((item) => normalizeItem(item, createdAt)).filter((item) => item !== null) : [];
@@ -863186,7 +863921,7 @@ class WorkPlanStore {
     };
   }
   createEmptyPlan() {
-    const time4 = nowMs3();
+    const time4 = nowMs2();
     return {
       id: createPlanId(this.options.projectId, this.options.projectRoot),
       projectId: this.options.projectId,
@@ -863989,7 +864724,7 @@ function createRuntimeServices2(options) {
     workingDirectory,
     isEnabled: () => false
   });
-  const processRegistry = createProcessRegistry({
+  const processRegistry = withFleetArchive(createProcessRegistry({
     agentManager,
     wrfcController,
     orchestrationEngine,
@@ -864002,10 +864737,18 @@ function createRuntimeServices2(options) {
     messageBus: agentMessageBus,
     automationManager,
     runtimeBus: options.runtimeBus
-  });
+  }));
   const workspaceCheckpointManager = new WorkspaceCheckpointManager({
     workspaceRoot: workingDirectory
   });
+  registerGatewayVerbGroups(gatewayMethods, {
+    processRegistry,
+    workspaceCheckpointManager,
+    sessionBroker,
+    secretsManager,
+    approvalBroker,
+    shellPaths
+  });
   return {
     workingDirectory,
     homeDirectory,
@@ -975001,8 +975744,8 @@ function formatDigestTime(at, from = Date.now()) {
     return `yesterday ${time4}`;
   return `${d4.toLocaleDateString(undefined, { month: "short", day: "numeric" })} ${time4}`;
 }
-function formatRelativeTime(targetMs, nowMs4 = Date.now()) {
-  const diffMs = targetMs - nowMs4;
+function formatRelativeTime(targetMs, nowMs3 = Date.now()) {
+  const diffMs = targetMs - nowMs3;
   if (diffMs <= 0)
     return "soon";
   const diffMin = Math.round(diffMs / 60000);