@pellux/goodvibes-tui 1.24.0 → 1.24.1

package/CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes to GoodVibes TUI.
 
 ---
 
+## [1.24.1] - 2026-07-27
+
+### Changes
+
+- Fixed: stopping the daemon left work running. The inbox retention sweep and the per-account inbound pollers kept ticking after shutdown, and a daemon that never finished starting — a port already in use, a short-lived run — left everything its construction had started running with nothing to stop it.
+- Fixed: agent runs the daemon was hosting are now cancelled when it shuts down. One left running had nowhere to report to and nothing to write into: the registries and event bus it reports through are already gone by then. It also keeps an in-flight provider call alive, sleeping out a retry it no longer has any reason to finish.
+- Fixed: a close arriving while the inbox cursor store was still opening could race it.
+
 ## [1.24.0] - 2026-07-27
 
 ### Changes

package/README.md

@@ -2,7 +2,7 @@
 
 [![CI](https://github.com/mgd34msu/goodvibes-tui/actions/workflows/ci.yml/badge.svg)](https://github.com/mgd34msu/goodvibes-tui/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Version](https://img.shields.io/badge/version-1.24.0-blue.svg)](https://github.com/mgd34msu/goodvibes-tui)
+[![Version](https://img.shields.io/badge/version-1.24.1-blue.svg)](https://github.com/mgd34msu/goodvibes-tui)
 
 GoodVibes is a terminal console for coding and operations work with an AI model. You run `goodvibes` in a project directory and get a full-screen terminal app where you talk to a model that can read and edit your files, run shell commands, search the web, and hand work off to background agents — asking your permission before anything that writes or executes. It talks to many model providers (OpenAI, Anthropic, Gemini, Bedrock, Copilot, OpenRouter and other OpenAI-compatible gateways, plus local servers like Ollama and LM Studio that it finds on startup), keeps its settings, sessions, and secrets on your own machine, and shows you the token count and running cost of every turn. Alongside the conversation, panels turn background work — running agents, git state, diffs, tokens, cost — into live control rooms.
 

package/docs/foundation-artifacts/operator-contract.json

@@ -3,7 +3,7 @@
   "product": {
     "id": "goodvibes",
     "surface": "operator",
-    "version": "1.17.0"
+    "version": "1.17.2"
   },
   "auth": {
     "modes": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-tui",
-  "version": "1.24.0",
+  "version": "1.24.1",
   "description": "Terminal-native GoodVibes product for coding, operations, automation, knowledge, channels, and daemon-backed control-plane workflows.",
   "type": "module",
   "main": "src/main.ts",
@@ -106,8 +106,8 @@
     "@anthropic-ai/vertex-sdk": "^0.16.0",
     "@ast-grep/napi": "^0.42.0",
     "@aws/bedrock-token-generator": "^1.1.0",
-    "@pellux/goodvibes-sdk": "1.17.0",
-    "@pellux/goodvibes-terminal-shell": "1.17.0",
+    "@pellux/goodvibes-sdk": "1.17.2",
+    "@pellux/goodvibes-terminal-shell": "1.17.2",
     "bash-language-server": "^5.6.0",
     "fuse.js": "^7.1.0",
     "graphql": "^16.13.2",

package/src/daemon/cli.ts

@@ -426,15 +426,17 @@ async function main(): Promise<void> {
     // daemon.stop() drives the ordered inbound teardown: it stops every gated
     // consumer and only then broadcasts the resignation, so another node on
     // this network takes over in about a second instead of waiting out the
-    // crash timeout. Handler surfaces (inbox store, catalog handlers) are
-    // released afterwards — before this, a SIGTERM left the inbox cursor store
-    // open and relied on process exit to clear the poll timers.
+    // crash timeout.
+    //
+    // This process built the runtime graph and handed it to DaemonServer, so by
+    // the SDK's ownership rule the facade leaves it alone — nothing else stops
+    // these pollers. Without dispose() the config watch, fleet tick, memory
+    // governor, watcher registry and six more kept ticking until process exit.
+    // The handler surfaces (inbox store + its poll timers, catalog handlers) are
+    // the FIRST thing dispose() unwinds — they are on the disposal owner list
+    // now rather than sequenced by hand here, which is what makes every other
+    // shutdown path stop them too instead of only this one.
     const stop = Promise.allSettled([listener.stop(), daemon.stop()])
-      .then(() => runtimeServices.daemonHandlers.unregister())
-      // This process built the runtime graph and handed it to DaemonServer, so
-      // by the SDK's ownership rule the facade leaves it alone — nothing else
-      // stops these pollers. Without this the config watch, fleet tick, memory
-      // governor, watcher registry and six more kept ticking until process exit.
       .then(() => { runtimeServices.dispose(); })
       .then(() => 'done' as const);
     const result = await Promise.race([stop, timeout]);

package/src/daemon/handlers/inbox/cursor-store.ts

@@ -140,6 +140,15 @@ export class InboxCursorStore {
   private readonly setIntervalImpl: typeof setInterval;
   private readonly clearIntervalImpl: typeof clearInterval;
   private sweepTimer: ReturnType<typeof setInterval> | null = null;
+  /**
+   * Set by close(). `init()` is async and arms the retention timer only after
+   * two awaits, so a surface that is torn down while its bootstrap is still in
+   * flight would otherwise arm a timer AFTER the only thing that could clear it
+   * had already run. That is not hypothetical: registerInboxMethods() kicks
+   * init() off without awaiting it, so any shutdown inside the first tick of a
+   * daemon's life hits exactly this window.
+   */
+  private closed = false;
 
   constructor(
     workingDirectory: string,
@@ -201,7 +210,7 @@ export class InboxCursorStore {
   }
 
   private startSweepTimer(): void {
-    if (this.sweepTimer !== null || this.sweepIntervalMs <= 0) return;
+    if (this.closed || this.sweepTimer !== null || this.sweepIntervalMs <= 0) return;
     const handle = this.setIntervalImpl(() => {
       void this.runSweep();
     }, this.sweepIntervalMs);
@@ -415,6 +424,8 @@ export class InboxCursorStore {
 
   /** Stop the retention timer, flush (best-effort), then close the database. */
   async close(): Promise<void> {
+    if (this.closed) return;
+    this.closed = true;
     this.stopSweepTimer();
     try {
       await this.flush();

package/src/daemon/handlers/inbox/poller.ts

@@ -51,6 +51,15 @@ export class InboundPoller {
   private readonly statuses = new Map<string, ProviderStatus>();
   private readonly inFlight = new Set<string>();
   private started = false;
+  /**
+   * Set by stop(), which the surface teardown calls and nothing else — unlike
+   * stopProvider(), which a leadership handover uses and which must stay
+   * resumable. Once the surface is released no interval may be armed again,
+   * including by work that was already in flight: registerInboxMethods() starts
+   * the store bootstrap without awaiting it, so a teardown during that window
+   * would otherwise be followed by a start() that nothing is left to undo.
+   */
+  private released = false;
 
   constructor(options: PollerOptions) {
     this.adapters = options.adapters;
@@ -66,7 +75,7 @@ export class InboundPoller {
 
   /** Begin per-provider interval loops. Idempotent. Does NOT poll immediately. */
   start(): void {
-    if (this.started) return;
+    if (this.released || this.started) return;
     this.started = true;
     for (const id of this.adapters.keys()) this.startProvider(id);
   }
@@ -81,7 +90,7 @@ export class InboundPoller {
    * addressable per provider, and the blanket calls are fan-outs over it.
    */
   startProvider(id: string): void {
-    if (this.timers.has(id)) return;
+    if (this.released || this.timers.has(id)) return;
     const adapter = this.adapters.get(id);
     if (!adapter) return;
     const handle = this.setIntervalImpl(() => {
@@ -187,8 +196,9 @@ export class InboundPoller {
     });
   }
 
-  /** Stop all interval loops. Idempotent. */
+  /** Release the poller for good: stop every interval loop, and refuse to arm another. Idempotent. */
   stop(): void {
+    this.released = true;
     for (const handle of this.timers.values()) {
       this.clearIntervalImpl(handle);
     }

package/src/daemon/handlers/index.ts

@@ -88,7 +88,16 @@ export function registerDaemonHandlers(
   const remote = providers.registerRemote(ctx);
   teardowns.push(remote.unregister);
 
+  // Idempotent: teardown is reachable from more than one shutdown path now that
+  // the runtime disposal scope owns it, and the surfaces underneath are not all
+  // safe to unwind twice — the inbox surface closes a SQLite handle, which a
+  // second pass would close again inside a floating promise (an unhandled
+  // rejection, not a caught one). Running once is also simply the honest
+  // meaning of "release these surfaces".
+  let torn = false;
   const unregister: Unregister = () => {
+    if (torn) return;
+    torn = true;
     for (let i = teardowns.length - 1; i >= 0; i -= 1) {
       try {
         teardowns[i]!();

package/src/runtime/agent-graph-composition.ts

@@ -0,0 +1,78 @@
+/**
+ * agent-graph-composition.ts — the graph that runs agents.
+ *
+ * Six collaborators that are only meaningful as a set, so they are built as
+ * one: a message bus, the archetype loader, the orchestrator that executes a
+ * run, the manager that owns the records, the context-accounting holder, and
+ * the WRFC controller. Every one of them holds a reference to at least one
+ * other, and two of the links are circular — the orchestrator writes
+ * conversation snapshots back through the manager, and the manager drives the
+ * WRFC controller which was built from the manager. Assembled anywhere but in
+ * one place, a half-wired graph looks correct and silently drops either the
+ * snapshot bridge or the review loop.
+ *
+ * It is also the graph whose runs `cancelHostedAgentRuns` cancels at disposal:
+ * the manager returned here is the one the runtime hands to the SDK's
+ * `cancelAllAgentRuns`.
+ */
+import { join } from 'node:path';
+import { AgentMessageBus, AgentOrchestrator, ArchetypeLoader, WrfcController } from '@pellux/goodvibes-sdk/platform/agents';
+import { AgentManager, ContextAccountingHolder } from '@pellux/goodvibes-sdk/platform/tools';
+import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
+import type { ProviderRegistry } from '@pellux/goodvibes-sdk/platform/providers';
+import type { RuntimeEventBus } from '@/runtime/index.ts';
+
+export interface AgentGraph {
+  readonly agentMessageBus: AgentMessageBus;
+  readonly archetypeLoader: ArchetypeLoader;
+  readonly agentOrchestrator: AgentOrchestrator;
+  readonly agentManager: AgentManager;
+  readonly contextAccountingHolder: ContextAccountingHolder;
+  readonly wrfcController: WrfcController;
+}
+
+/** Build the agent-execution graph, fully wired in both directions. */
+export function createAgentGraph(options: {
+  readonly runtimeBus: RuntimeEventBus;
+  readonly workingDirectory: string;
+  readonly configManager: ConfigManager;
+  readonly providerRegistry: ProviderRegistry;
+}): AgentGraph {
+  const agentMessageBus = new AgentMessageBus();
+  agentMessageBus.setRuntimeBus(options.runtimeBus);
+  const archetypeLoader = new ArchetypeLoader(join(options.workingDirectory, '.goodvibes', 'agents'));
+  const agentOrchestrator = new AgentOrchestrator({
+    messageBus: agentMessageBus,
+  });
+  agentOrchestrator.setRuntimeBus(options.runtimeBus);
+  const agentManager = new AgentManager({
+    archetypeLoader,
+    messageBus: agentMessageBus,
+    executor: agentOrchestrator,
+    configManager: options.configManager,
+    // The live registry lets a bare model id in a spawn() override resolve
+    // through the shared resolver instead of being rejected as unqualified.
+    providerRegistry: options.providerRegistry,
+  });
+  const contextAccountingHolder = new ContextAccountingHolder();
+  // Conversation-snapshot bridge (mirrors the SDK's own createRuntimeServices).
+  agentOrchestrator.setConversationSink({
+    register: (agentId, source) => agentManager.registerConversationSource(agentId, source),
+    release: (agentId) => agentManager.releaseConversationSource(agentId),
+  });
+  agentManager.setRuntimeBus(options.runtimeBus);
+  const wrfcController = new WrfcController(options.runtimeBus, agentMessageBus, {
+    agentManager,
+    configManager: options.configManager,
+    projectRoot: options.workingDirectory,
+  });
+  agentManager.setWrfcController(wrfcController);
+  return {
+    agentMessageBus,
+    archetypeLoader,
+    agentOrchestrator,
+    agentManager,
+    contextAccountingHolder,
+    wrfcController,
+  };
+}

package/src/runtime/disposal-wiring.ts

@@ -38,6 +38,15 @@ export { createDisposalScope };
 export interface SurfaceRuntimePollerOwners extends Omit<RuntimePollerOwners, 'stopConfigWatch'> {
   /** Fork-only: the repeating crash-residue sweep (durability-services.ts). */
   readonly stopDurabilityHousekeeping: () => void;
+  /**
+   * Fork-only: the daemon handler surfaces (daemon-handler-composition.ts).
+   *
+   * `unregister()` detaches the gateway handlers AND stops the two pollers this
+   * product's inbox surface owns — the retention sweep inside `InboxCursorStore`
+   * and the per-provider `InboundPoller` intervals. The SDK does not know either
+   * exists, so if this surface does not stop them nothing does.
+   */
+  readonly daemonHandlers: { readonly unregister: () => void };
 }
 
 /**
@@ -63,4 +72,12 @@ export function registerSurfaceRuntimePollers(
 ): void {
   registerRuntimePollers(registry, { ...services, stopConfigWatch: extras.stopConfigWatch });
   registry.add('durability housekeeping', services.stopDurabilityHousekeeping);
+  // Registered LAST so it tears down FIRST (the scope unwinds in reverse), which
+  // is the order daemon/cli.ts already used by hand: release the handler surfaces
+  // — closing the inbox store and stopping its poll timers — before the pollers
+  // the rest of the graph owns. Being on this list is what makes a plain
+  // `dispose()` total: every shutdown path (daemon/cli.ts, main.ts's teardown
+  // registry, the one-shot CLI commands) now stops these two, not just the one
+  // that remembered to call `unregister()` itself.
+  registry.add('daemon handler surfaces', () => services.daemonHandlers.unregister());
 }

package/src/runtime/services.ts

@@ -20,7 +20,7 @@ import { createKnowledgeServices } from './knowledge-services.ts';
 import { MediaProviderRegistry, ensureBuiltinMediaProviders } from '@pellux/goodvibes-sdk/platform/media';
 import { MultimodalService } from '@pellux/goodvibes-sdk/platform/multimodal';
 import { AgentMessageBus, AgentOrchestrator, ArchetypeLoader, WrfcController } from '@pellux/goodvibes-sdk/platform/agents';
-import { AgentManager, ContextAccountingHolder, OverflowHandler, ProcessManager, createWorkflowServices, type WorkflowServices } from '@pellux/goodvibes-sdk/platform/tools';
+import { AgentManager, ContextAccountingHolder, OverflowHandler, ProcessManager, cancelAllAgentRuns, createWorkflowServices, type WorkflowServices } from '@pellux/goodvibes-sdk/platform/tools';
 import { FileStateCache, FileUndoManager, MemoryConsolidationScheduler, MemoryEmbeddingProviderRegistry, MemoryRegistry, MemoryStore, ModeManager, ProjectIndex, resolveCanonicalMemoryDbPath, type CodeIndexStore, type CodeIndexReindexScheduler } from '@pellux/goodvibes-sdk/platform/state';
 import type { StoreSnapshotScheduler } from '@pellux/goodvibes-sdk/platform/state/store-snapshots';
 import type { UserPermissionRuleStore } from '@pellux/goodvibes-sdk/platform/permissions';
@@ -56,6 +56,7 @@ import { ApiTokenAuditor, UserAuthManager } from '@pellux/goodvibes-sdk/platform
 import { WebhookNotifier } from '@pellux/goodvibes-sdk/platform/integrations';
 import { McpRegistry } from '@pellux/goodvibes-sdk/platform/mcp';
 import { createRemoteExecutionServices } from './remote-execution-composition.ts';
+import { createAgentGraph } from './agent-graph-composition.ts';
 import { BenchmarkStore, CacheHitTracker, FavoritesStore, ModelLimitsService, ProviderCapabilityRegistry, ProviderOptimizer, ProviderRegistry } from '@pellux/goodvibes-sdk/platform/providers';
 import { KeybindingsManager } from '../input/keybindings.ts';
 import { AdaptivePlanner, DeterministicReplayEngine, ExecutionPlanManager, SessionLineageTracker, SessionMemoryStore } from '@pellux/goodvibes-sdk/platform/core';
@@ -232,6 +233,15 @@ export interface RuntimeServices {
   readonly integrationHelpers: IntegrationHelperService;
   /** Re-root path-bound stores (MemoryStore, ProjectIndex) to a new working directory, called by WorkspaceSwapManager after verification; stores needing a process restart just warn-log and keep serving the old path until the daemon restarts with the new --working-dir. */
   rerootStores(newWorkingDir: string): Promise<void>;
+  /**
+   * Cancel the agent runs this graph is hosting, returning how many.
+   *
+   * Required by the SDK's RuntimePollerOwners: by dispose() time the fleet
+   * registry, orchestration engine, process registry and bus these runs report
+   * through are already down, so a run still described as "running" is orphaned
+   * rather than preserved.
+   */
+  cancelHostedAgentRuns(): number;
   dispose(): void; // Stop every poller this graph started; best-effort, total, idempotent. This surface owns its graph — see disposal-wiring.ts.
 }
 
@@ -342,34 +352,14 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     runtimeStore: options.runtimeStore,
     runtimeBus: options.runtimeBus,
   });
-  const agentMessageBus = new AgentMessageBus();
-  agentMessageBus.setRuntimeBus(options.runtimeBus);
-  const archetypeLoader = new ArchetypeLoader(join(workingDirectory, '.goodvibes', 'agents'));
-  const agentOrchestrator = new AgentOrchestrator({
-    messageBus: agentMessageBus,
-  });
-  agentOrchestrator.setRuntimeBus(options.runtimeBus);
-  const agentManager = new AgentManager({
-    archetypeLoader,
-    messageBus: agentMessageBus,
-    executor: agentOrchestrator,
-    configManager,
-    // The live registry lets a bare model id in a spawn() override resolve
-    // through the shared resolver instead of being rejected as unqualified.
-    providerRegistry,
-  });
-  const contextAccountingHolder = new ContextAccountingHolder();
-  agentOrchestrator.setConversationSink({ // Conversation-snapshot bridge (mirrors the SDK's own createRuntimeServices)
-    register: (agentId, source) => agentManager.registerConversationSource(agentId, source),
-    release: (agentId) => agentManager.releaseConversationSource(agentId),
-  });
-  agentManager.setRuntimeBus(options.runtimeBus);
-  const wrfcController = new WrfcController(options.runtimeBus, agentMessageBus, {
-    agentManager,
-    configManager,
-    projectRoot: workingDirectory,
+  // The agent-execution graph, wired in both directions; see
+  // agent-graph-composition.ts for why the six are built as one.
+  const {
+    agentMessageBus, archetypeLoader, agentOrchestrator,
+    agentManager, contextAccountingHolder, wrfcController,
+  } = createAgentGraph({
+    runtimeBus: options.runtimeBus, workingDirectory, configManager, providerRegistry,
   });
-  agentManager.setWrfcController(wrfcController);
   const hookDispatcher = new HookDispatcher({ agentManager, toolLLM, projectRoot: workingDirectory }, hookActivityTracker);
   configManager.attachHookDispatcher(hookDispatcher);
   const hookWorkbench = createHookWorkbench({
@@ -794,6 +784,13 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     workspaceCheckpointManager,
     integrationHelpers,
     rerootStores: createStoreRerooter({ codeIndexStore, projectIndex }),
+    // Cancels the agent runs this graph was hosting. By dispose() time the
+    // fleet registry, orchestration engine, process registry and bus these runs
+    // report through are already down, so a run still described as "running" is
+    // orphaned rather than preserved — and this is the only shutdown-reachable
+    // way to abort its in-flight provider call instead of letting it sleep out
+    // a retry backoff nobody is waiting on.
+    cancelHostedAgentRuns: () => cancelAllAgentRuns(agentManager),
     dispose: (): void => disposalScope.dispose(),
   };
   registerSurfaceRuntimePollers(disposalScope.registry, services, { stopConfigWatch }); return services;

package/src/version.ts

@@ -6,7 +6,7 @@ import { join } from 'node:path';
 // The prebuild script updates the fallback value before compilation.
 // Uses import.meta.dir (Bun) to locate package.json relative to this file,
 // which is correct regardless of the process working directory.
-let _version = '1.24.0';
+let _version = '1.24.1';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8'));
   // Only trust a version read from OUR OWN package.json. A Bun single-file