@pellux/goodvibes-agent 1.7.0 → 1.8.0

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(() => {
@@ -831868,9 +832390,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 +834250,7 @@ function createRuntimeServices(options) {
     projectRoot: workingDirectory,
     priceUsage
   });
-  const processRegistry = createProcessRegistry({
+  const processRegistry = withFleetArchive(createProcessRegistry({
     agentManager,
     wrfcController,
     orchestrationEngine,
@@ -833608,7 +834266,7 @@ function createRuntimeServices(options) {
     runtimeBus: options.runtimeBus,
     priceUsage,
     codeIndexService: codeIndexStore
-  });
+  }));
   registerGatewayVerbGroups(gatewayMethods, { processRegistry, workspaceCheckpointManager, sessionBroker, secretsManager, approvalBroker, shellPaths });
   return {
     workingDirectory,
@@ -837756,7 +838414,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.0";
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, "..", "package.json"), "utf-8"));
   _version = typeof pkg.version === "string" ? pkg.version : _version;
@@ -839872,6 +840530,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 +840724,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 +840811,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 +841450,9 @@ class Orchestrator {
           this.conversation.addSystemMessage(msg);
         }
       }
+      for (const event of eventsToReplay) {
+        this.replayQueue.acknowledge(event.id);
+      }
       this.requestRender();
     }
     this.followUpRuntime.scheduleFlush();
@@ -863989,7 +864666,7 @@ function createRuntimeServices2(options) {
     workingDirectory,
     isEnabled: () => false
   });
-  const processRegistry = createProcessRegistry({
+  const processRegistry = withFleetArchive(createProcessRegistry({
     agentManager,
     wrfcController,
     orchestrationEngine,
@@ -864002,7 +864679,7 @@ function createRuntimeServices2(options) {
     messageBus: agentMessageBus,
     automationManager,
     runtimeBus: options.runtimeBus
-  });
+  }));
   const workspaceCheckpointManager = new WorkspaceCheckpointManager({
     workspaceRoot: workingDirectory
   });
@@ -895000,13 +895677,13 @@ init_state();
 
 // src/input/commands/recall-shared.ts
 var VALID_CLASSES = ["decision", "constraint", "incident", "pattern", "fact", "risk", "runbook", "architecture", "ownership"];
-var VALID_SCOPES = ["session", "project", "team"];
+var VALID_SCOPES2 = ["session", "project", "team"];
 var VALID_REVIEW_STATES = ["fresh", "reviewed", "stale", "contradicted"];
 function isValidClass(s4) {
   return VALID_CLASSES.includes(s4);
 }
 function isValidScope(s4) {
-  return VALID_SCOPES.includes(s4);
+  return VALID_SCOPES2.includes(s4);
 }
 function isValidReviewState(s4) {
   return VALID_REVIEW_STATES.includes(s4);
@@ -895049,7 +895726,7 @@ function handleRecallSearch(args2, context) {
     if (isValidScope(scope))
       filter.scope = scope;
     else {
-      context.print(`[memory] Unknown scope "${scope}". Valid values ${VALID_SCOPES.join(", ")}.`);
+      context.print(`[memory] Unknown scope "${scope}". Valid values ${VALID_SCOPES2.join(", ")}.`);
       return;
     }
   }
@@ -895224,7 +895901,7 @@ function handleRecallList(args2, context) {
   if (scopeIdx !== -1 && args2[scopeIdx + 1]) {
     const scope = args2[scopeIdx + 1];
     if (!isValidScope(scope)) {
-      context.print(`[memory] Unknown scope "${scope}". Valid values ${VALID_SCOPES.join(", ")}.`);
+      context.print(`[memory] Unknown scope "${scope}". Valid values ${VALID_SCOPES2.join(", ")}.`);
       return;
     }
     filter.scope = scope;
@@ -895274,7 +895951,7 @@ async function handleRecallAdd(args2, context) {
   const tags = tagsRaw ? tagsRaw.split(",").map((token) => token.trim()).filter(Boolean) : [];
   const scope = scopeRaw && isValidScope(scopeRaw) ? scopeRaw : "project";
   if (scopeRaw && !isValidScope(scopeRaw)) {
-    context.print(`[memory] Invalid scope "${scopeRaw}". Valid values ${VALID_SCOPES.join(", ")}.`);
+    context.print(`[memory] Invalid scope "${scopeRaw}". Valid values ${VALID_SCOPES2.join(", ")}.`);
     return;
   }
   const provenance = [];
@@ -895409,7 +896086,7 @@ function handleRecallExport(args2, context) {
   if (scopeIdx !== -1 && commandArgs[scopeIdx + 1]) {
     const scope = commandArgs[scopeIdx + 1];
     if (!isValidScope(scope)) {
-      context.print(`[memory] Unknown scope "${scope}". Valid values ${VALID_SCOPES.join(", ")}.`);
+      context.print(`[memory] Unknown scope "${scope}". Valid values ${VALID_SCOPES2.join(", ")}.`);
       return;
     }
     filter.scope = scope;
@@ -895488,7 +896165,7 @@ function handleRecallHandoffExport(args2, context) {
   const scopeIdx = commandArgs.indexOf("--scope");
   const scopeRaw = scopeIdx !== -1 ? commandArgs[scopeIdx + 1] : "team";
   if (!scopeRaw || !isValidScope(scopeRaw)) {
-    context.print(`[memory] Unknown scope "${scopeRaw ?? ""}". Valid values ${VALID_SCOPES.join(", ")}.`);
+    context.print(`[memory] Unknown scope "${scopeRaw ?? ""}". Valid values ${VALID_SCOPES2.join(", ")}.`);
     return;
   }
   const bundle = memory.exportBundle({ scope: scopeRaw });
@@ -895604,7 +896281,7 @@ function handleRecallPromote(args2, context) {
   const id = parsed.rest[0];
   const scope = parsed.rest[1];
   if (!id || !scope || !isValidScope(scope)) {
-    context.print(`[memory] Usage: /memory promote <id> <${VALID_SCOPES.join("|")}> --yes`);
+    context.print(`[memory] Usage: /memory promote <id> <${VALID_SCOPES2.join("|")}> --yes`);
     return;
   }
   if (!parsed.yes) {
@@ -909194,7 +909871,7 @@ async function tryWireMemoryCommand(runtime2, normalized, rest) {
 
 // src/cli/memory-command.ts
 var VALID_CLASSES2 = ["decision", "constraint", "incident", "pattern", "fact", "risk", "runbook", "architecture", "ownership"];
-var VALID_SCOPES3 = ["session", "project", "team"];
+var VALID_SCOPES4 = ["session", "project", "team"];
 var VALID_REVIEW_STATES3 = ["fresh", "reviewed", "stale", "contradicted"];
 var VALID_PROVENANCE_KINDS = ["session", "turn", "task", "event", "file"];
 var VALUE_OPTIONS = new Set([
@@ -909294,7 +909971,7 @@ function isMemoryClass2(value) {
   return VALID_CLASSES2.includes(value);
 }
 function isMemoryScope2(value) {
-  return VALID_SCOPES3.includes(value);
+  return VALID_SCOPES4.includes(value);
 }
 function isReviewState(value) {
   return VALID_REVIEW_STATES3.includes(value);
@@ -909309,7 +909986,7 @@ function requireClass(value) {
 }
 function requireScope(value) {
   if (!value || !isMemoryScope2(value))
-    throw new Error(`Invalid memory scope "${value ?? ""}". Valid values ${VALID_SCOPES3.join(", ")}`);
+    throw new Error(`Invalid memory scope "${value ?? ""}". Valid values ${VALID_SCOPES4.join(", ")}`);
   return value;
 }
 function optionalScope(value) {
@@ -963327,7 +964004,7 @@ var invokeContractRoute2 = exports_transport.invokeContractRoute;
 var openContractRouteStream2 = exports_transport.openContractRouteStream;
 var requireContractRoute2 = exports_transport.requireContractRoute;
 var isAbortError6 = exports_transport.isAbortError;
-var openServerSentEventStream3 = exports_transport.openServerSentEventStream;
+var openServerSentEventStream2 = exports_transport.openServerSentEventStream;
 var createOperatorRemoteClient2 = exports_transport.createOperatorRemoteClient;
 var createPeerRemoteClient2 = exports_transport.createPeerRemoteClient;
 var buildEventSourceUrl2 = exports_transport.buildEventSourceUrl;