@pellux/goodvibes-tui 1.17.0 → 1.19.0

package/src/runtime/idle-power-services.ts

@@ -0,0 +1,85 @@
+// ---------------------------------------------------------------------------
+// idle-power-services.ts — the idle-time / sleep-ownership / live-turn slice of
+// the runtime composition, extracted from services.ts (file-size hygiene).
+//
+// Mirrors the SDK's own createRuntimeServices wiring: idle-time memory
+// consolidation (learning.consolidation.*), host sleep ownership (power.*), and
+// the per-session live-turn control holder that backs the
+// sessions.toolCalls.cancel / sessions.queuedMessages.* wire verbs. Consolidation
+// receipts ride the SAME attach-time queue every other receipt uses — a run that
+// changed something records a one-line notice into the file-backed
+// feature-announcement store, drained on the next surface attach; a quiet run
+// records nothing.
+// ---------------------------------------------------------------------------
+
+import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
+import type { MemoryRegistry } from '@pellux/goodvibes-sdk/platform/state';
+import { MemoryConsolidationScheduler } from '@pellux/goodvibes-sdk/platform/state';
+import { SessionLiveTurnControlsHolder } from '@pellux/goodvibes-sdk/platform/control-plane';
+import { PowerManager, wireRuntimePower, createUnavailablePowerSeam } from '@pellux/goodvibes-sdk/platform/power';
+import { FeatureAnnouncementStore, featureAnnouncementsPath } from '@pellux/goodvibes-sdk/platform/runtime/feature-announcements';
+import type { RuntimeEventBus } from '@pellux/goodvibes-sdk/platform/runtime/state';
+import { formatConsolidationReceipt } from '../core/consolidation-receipt.ts';
+
+export interface IdlePowerServicesDeps {
+  readonly configManager: ConfigManager;
+  readonly memoryRegistry: MemoryRegistry;
+  readonly runtimeBus: RuntimeEventBus;
+  /** True when no session is busy — the consolidation scheduler's idle gate. */
+  readonly isIdle: () => boolean;
+  /** Sleep-edge checkpoint + a wake catch-up tick (store snapshots). */
+  readonly snapshotTick: () => void;
+  /** Wake catch-up: fire the automation heartbeat. */
+  readonly heartbeat: () => Promise<void>;
+  /**
+   * Host power seam. SDK 1.9.0 makes wireRuntimePower default an absent seam to
+   * the REAL host seam (createHostPowerSeam — which spawns systemd-inhibit and a
+   * dbus-monitor sleep-edge watcher). That spawn is a host-level side effect, so
+   * this fork mirrors the SDK's own createRuntimeServices: when no seam is passed
+   * we default to the NON-spawning unavailable seam, keeping test-constructed
+   * runtimes deterministic. Only the real long-lived compositions (the standalone
+   * daemon and the embedded interactive runtime, which itself IS the daemon) pass
+   * createHostPowerSeam() to opt into live OS keep-awake/idle-inhibit.
+   */
+  readonly powerSeam?: Parameters<typeof wireRuntimePower>[0]['seam'];
+}
+
+export interface IdlePowerServices {
+  readonly memoryConsolidationScheduler: MemoryConsolidationScheduler;
+  readonly powerManager: PowerManager;
+  readonly sessionLiveTurnControls: SessionLiveTurnControlsHolder;
+}
+
+/** Construct (and start) the idle-consolidation scheduler, power manager, and live-turn holder. */
+export function wireIdlePowerAndLiveTurn(deps: IdlePowerServicesDeps): IdlePowerServices {
+  const consolidationReceiptStore = new FeatureAnnouncementStore(featureAnnouncementsPath(deps.configManager));
+  const memoryConsolidationScheduler = new MemoryConsolidationScheduler({
+    memoryRegistry: deps.memoryRegistry,
+    configSource: deps.configManager,
+    isIdle: deps.isIdle,
+    onReceipt: (receipt) => {
+      const text = formatConsolidationReceipt(receipt);
+      if (text) consolidationReceiptStore.record(receipt.runId, text);
+    },
+  });
+  memoryConsolidationScheduler.start();
+  const sessionLiveTurnControls = new SessionLiveTurnControlsHolder();
+  const powerManager = wireRuntimePower({
+    readConfig: (key) => deps.configManager.get(key as Parameters<typeof deps.configManager.get>[0]),
+    writeConfig: (key, value) => deps.configManager.setDynamic(key as Parameters<typeof deps.configManager.setDynamic>[0], value),
+    // Live config subscription: an external edit to power.keepAwake (a settings-
+    // modal toggle, a hand-edited settings file) applies LIVE to the in-process
+    // manager — acquires/releases the inhibitor and lights the chip with no
+    // restart. This is the config-apply path for the EMBEDDED topology + the
+    // local chip; the external daemon is reached separately over the verb.
+    subscribeConfig: (key, cb) => (deps.configManager.subscribe as unknown as (k: string, c: (v: unknown) => void) => () => void)(key, (newValue) => cb(newValue)),
+    runtimeBus: deps.runtimeBus,
+    sleepCheckpoint: deps.snapshotTick,
+    wakeCatchUp: [() => memoryConsolidationScheduler.tick(), deps.snapshotTick, deps.heartbeat],
+    // Non-spawning default (see powerSeam doc above): without an explicit opt-in
+    // the seam is the honest unavailable one, NOT the spawning host seam that
+    // wireRuntimePower would otherwise pick for an undefined seam.
+    seam: deps.powerSeam ?? createUnavailablePowerSeam('runtime services constructed without a host power seam'),
+  });
+  return { memoryConsolidationScheduler, powerManager, sessionLiveTurnControls };
+}

package/src/runtime/index.ts

@@ -279,8 +279,10 @@ export const loadLastConversation = operations.loadLastConversation;
 export const loadRecoveryConversation = operations.loadRecoveryConversation;
 export const writeRecoveryFile = operations.writeRecoveryFile;
 export const deleteRecoveryFile = operations.deleteRecoveryFile;
+export const autoRestoreRecovery = operations.autoRestoreRecovery;
 export const checkRecoveryFile = operations.checkRecoveryFile;
 export const getRecoveryFilePath = operations.getRecoveryFilePath;
+export const getRecoveryDir = operations.getRecoveryDir;
 export const getLastSessionPointerPath = operations.getLastSessionPointerPath;
 export const writeLastSessionPointer = operations.writeLastSessionPointer;
 export const readLastSessionPointer = operations.readLastSessionPointer;

package/src/runtime/interaction-seams.ts

@@ -0,0 +1,109 @@
+// ---------------------------------------------------------------------------
+// interaction-seams.ts — the command-context interaction seams and the memory-
+// provenance UI controller, extracted from main.ts (file-size hygiene).
+//
+// The seams expose the in-process orchestrator's per-tool cancel and mid-turn
+// queue edit/delete, the power toggle/status, and the provenance-chip drill-in
+// to the command layer. The memory-provenance controller owns the "used N
+// memories" chip's state (the latest turn's metadata.memory.recordIds and the
+// expand flag), its per-turn capture, and its render.
+// ---------------------------------------------------------------------------
+
+import type { CommandContext } from '../input/command-registry.ts';
+import type { PowerManager } from '@pellux/goodvibes-sdk/platform/power';
+import type { Line } from '../types/grid.ts';
+import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
+import { createCancelToolCall, type ToolCancelOrchestrator } from '../core/turn-cancellation.ts';
+import { powerSurfaceFromState } from '../core/power-status.ts';
+import { memoryRecordIdsFromTurn, readMemoryShowProvenance } from '../core/memory-provenance.ts';
+import { UIFactory } from '../renderer/ui-factory.ts';
+
+/** The orchestrator surface the interaction seams need. */
+export interface InteractionOrchestrator extends ToolCancelOrchestrator {
+  listQueuedMessages(): ReadonlyArray<{ id: string; queuedAt: number; text: string }>;
+  editQueuedMessage(id: string, text: string): boolean;
+  deleteQueuedMessage(id: string): boolean;
+}
+
+export interface InteractionSeamDeps {
+  readonly orchestrator: InteractionOrchestrator;
+  readonly powerManager: PowerManager;
+  /** Topology-aware power projection (the chip source): the DAEMON's state in adopted-external mode. Falls back to the local manager when absent. */
+  readonly readPowerSurface?: (() => ReturnType<typeof powerSurfaceFromState>) | undefined;
+  readonly render: () => void;
+  readonly notify: (message: string) => void;
+  readonly getActiveToolCallId: () => string | undefined;
+  readonly toggleMemoryProvenance: () => void;
+}
+
+/** Wire the per-tool cancel, queue edit/delete, power, and memory-provenance seams onto the command context. */
+export function wireInteractionSeams(cc: CommandContext, deps: InteractionSeamDeps): void {
+  cc.cancelToolCall = createCancelToolCall(deps.orchestrator, deps.getActiveToolCallId, () => {
+    deps.notify('[Tool] Cancelled the running tool call — the turn continues.');
+    deps.render();
+  });
+  cc.listQueuedMessages = () => deps.orchestrator.listQueuedMessages();
+  cc.editQueuedMessage = (id, text) => { const ok = deps.orchestrator.editQueuedMessage(id, text); if (ok) deps.render(); return ok; };
+  cc.deleteQueuedMessage = (id) => { const ok = deps.orchestrator.deleteQueuedMessage(id); if (ok) deps.render(); return ok; };
+  cc.toggleMemoryProvenance = deps.toggleMemoryProvenance;
+  cc.getPowerState = () => (deps.readPowerSurface ? deps.readPowerSurface() : powerSurfaceFromState(deps.powerManager.getState()));
+  cc.setKeepAwake = async (enabled) => { const next = powerSurfaceFromState(await deps.powerManager.setKeepAwake(enabled)); deps.render(); return next; };
+}
+
+/** The memory-provenance chip UI: per-turn capture, drill-in state, and render. */
+export interface MemoryProvenanceUi {
+  /** Toggle the drill-in expand state (Alt+M). */
+  toggle(): void;
+  /** Capture the memory record ids from a completed turn's payload (metadata.memory.recordIds). */
+  onTurnCompleted(evt: unknown): void;
+  /** The chip lines for the current turn — empty when the setting is off or the turn used no memories. */
+  renderChip(width: number, configManager: Pick<ConfigManager, 'get'>): Line[];
+}
+
+/** A resolved provenance record summary (null = the record is no longer available). */
+type ResolvedRecord = { readonly summary: string; readonly cls: string } | null;
+
+/**
+ * Create the memory-provenance chip controller (default OFF; reads nothing when
+ * off). When the drill-in is expanded it RESOLVES each memory record id to its
+ * summary through the memory spine (the same host-or-daemon access the recall
+ * commands use, so an adopted daemon resolves over the wire) — per-id and
+ * lazily, so one forgotten record never blanks the rest and a collapsed chip
+ * costs nothing. Mirrors the webui's provenance detail fetch.
+ */
+export function createMemoryProvenanceUi(deps: {
+  readonly render: () => void;
+  readonly memorySpine: { get(id: string): Promise<{ summary: string; cls: string } | null> };
+}): MemoryProvenanceUi {
+  let latestRecordIds: readonly string[] = [];
+  let expanded = false;
+  // id -> resolved record (null = not found). Absent = not yet fetched.
+  const resolved = new Map<string, ResolvedRecord>();
+  const inFlight = new Set<string>();
+
+  const resolveExpanded = (): void => {
+    for (const id of latestRecordIds) {
+      if (resolved.has(id) || inFlight.has(id)) continue;
+      inFlight.add(id);
+      void deps.memorySpine.get(id)
+        .then((record) => { resolved.set(id, record ? { summary: record.summary, cls: record.cls } : null); })
+        .catch(() => { resolved.set(id, null); })
+        .finally(() => { inFlight.delete(id); deps.render(); });
+    }
+  };
+
+  return {
+    toggle() {
+      expanded = !expanded;
+      if (expanded) resolveExpanded();
+      deps.render();
+    },
+    onTurnCompleted(evt) { latestRecordIds = memoryRecordIdsFromTurn(evt); expanded = false; },
+    renderChip(width, configManager) {
+      if (!readMemoryShowProvenance(configManager) || latestRecordIds.length === 0) return [];
+      if (expanded) resolveExpanded(); // lazy: fetch any still-unresolved ids (idempotent)
+      const entries = latestRecordIds.map((id) => ({ id, record: resolved.has(id) ? resolved.get(id) : undefined }));
+      return UIFactory.createMemoryProvenanceChip(width, latestRecordIds.length, entries, expanded);
+    },
+  };
+}

package/src/runtime/knowledge-services.ts

@@ -0,0 +1,94 @@
+// ---------------------------------------------------------------------------
+// knowledge-services.ts — the knowledge/wiki + home-graph stack (TUI wiring)
+//
+// Constructs the three KnowledgeStores (regular wiki, agent, home-graph), their
+// semantic services, the ingest services, the home-graph service, and the
+// project-planning + work-plan stores. Extracted into its own module rather
+// than built inline in services.ts, which sits at the architecture check's
+// 800-line cap (scripts/check-architecture.ts) — new/large construction blocks
+// get their own module and a single wiring call there (mirrors
+// createWorkstreamServices / createDurabilityServices / createCodeIndexServices).
+//
+// The semantic services + ingest services receive the memory-governor
+// backpressure seams (isBackgroundPaused for the knowledge-self-improvement job
+// + admitExpensiveWork for the critical-tier refusal), mirroring the SDK's own
+// createRuntimeServices. The web-knowledge gap repairer is wired by the caller
+// AFTER webSearchService exists (it is constructed later in services.ts), using
+// the semantic + ingest handles this returns.
+// ---------------------------------------------------------------------------
+
+import {
+  HomeGraphService,
+  GOODVIBES_AGENT_KNOWLEDGE_DB_FILE,
+  HOME_GRAPH_KNOWLEDGE_EXTENSION,
+  KnowledgeService,
+  KnowledgeSemanticService,
+  KnowledgeStore,
+  ProjectPlanningService,
+  createProviderBackedKnowledgeSemanticLlm,
+  projectPlanningProjectIdFromPath,
+} from '@pellux/goodvibes-sdk/platform/knowledge';
+import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
+import type { ProviderRegistry } from '@pellux/goodvibes-sdk/platform/providers';
+import type { ArtifactStore } from '@pellux/goodvibes-sdk/platform/artifacts';
+import type { MemoryRegistry } from '@pellux/goodvibes-sdk/platform/state';
+import type { RuntimeEventBus } from '@/runtime/index.ts';
+import { WorkPlanStore } from '../work-plans/work-plan-store.ts';
+
+const REGULAR_KNOWLEDGE_DB_FILE = 'knowledge-wiki.sqlite';
+const HOME_GRAPH_KNOWLEDGE_DB_FILE = 'knowledge-home-graph.sqlite';
+
+export interface KnowledgeServicesDeps {
+  readonly configManager: ConfigManager;
+  readonly providerRegistry: ProviderRegistry;
+  readonly artifactStore: ArtifactStore;
+  readonly memoryRegistry: MemoryRegistry;
+  readonly runtimeBus: RuntimeEventBus;
+  readonly workingDirectory: string;
+  readonly homeDirectory: string;
+  /** True while the 'knowledge-self-improvement' job is governor-paused. */
+  readonly isBackgroundPaused: () => boolean;
+  /** Critical-tier admission gate for expensive knowledge work. */
+  readonly admitExpensiveWork: (label: string) => { allowed: boolean; reason?: string | undefined };
+}
+
+export interface KnowledgeServices {
+  readonly knowledgeStore: KnowledgeStore;
+  readonly agentKnowledgeStore: KnowledgeStore;
+  readonly homeGraphKnowledgeStore: KnowledgeStore;
+  readonly knowledgeSemanticService: KnowledgeSemanticService;
+  readonly homeGraphSemanticService: KnowledgeSemanticService;
+  readonly agentKnowledgeSemanticService: KnowledgeSemanticService;
+  readonly knowledgeService: KnowledgeService;
+  readonly agentKnowledgeService: KnowledgeService;
+  readonly homeGraphService: HomeGraphService;
+  readonly projectPlanningService: ProjectPlanningService;
+  readonly projectPlanningProjectId: string;
+  readonly workPlanStore: WorkPlanStore;
+}
+
+/** Construct the knowledge/wiki + home-graph stack with governor backpressure wired in. */
+export function createKnowledgeServices(deps: KnowledgeServicesDeps): KnowledgeServices {
+  const { configManager, providerRegistry, artifactStore, memoryRegistry, runtimeBus, isBackgroundPaused, admitExpensiveWork } = deps;
+  const knowledgeStore = new KnowledgeStore({ configManager, dbFileName: REGULAR_KNOWLEDGE_DB_FILE });
+  const agentKnowledgeStore = new KnowledgeStore({ configManager, dbFileName: GOODVIBES_AGENT_KNOWLEDGE_DB_FILE });
+  const homeGraphKnowledgeStore = new KnowledgeStore({ configManager, dbFileName: HOME_GRAPH_KNOWLEDGE_DB_FILE });
+  const knowledgeSemanticLlm = createProviderBackedKnowledgeSemanticLlm(providerRegistry, { timeoutMs: 20_000, maxConcurrent: 1 });
+  const knowledgeSemanticService = new KnowledgeSemanticService(knowledgeStore, { llm: knowledgeSemanticLlm, maxLlmSourcesPerReindex: 3, isBackgroundPaused, admitExpensiveWork });
+  const homeGraphSemanticService = new KnowledgeSemanticService(homeGraphKnowledgeStore, { llm: knowledgeSemanticLlm, maxLlmSourcesPerReindex: 3, objectProfiles: HOME_GRAPH_KNOWLEDGE_EXTENSION.objectProfiles, isBackgroundPaused, admitExpensiveWork });
+  const agentKnowledgeSemanticService = new KnowledgeSemanticService(agentKnowledgeStore, { llm: knowledgeSemanticLlm, maxLlmSourcesPerReindex: 3, isBackgroundPaused, admitExpensiveWork });
+  const knowledgeService = new KnowledgeService(knowledgeStore, artifactStore, undefined, { memoryRegistry, runtimeBus, semanticService: knowledgeSemanticService, admitExpensiveWork });
+  knowledgeService.attachRuntimeBus(runtimeBus);
+  const agentKnowledgeService = new KnowledgeService(agentKnowledgeStore, artifactStore, undefined, { memoryRegistry, runtimeBus, semanticService: agentKnowledgeSemanticService, admitExpensiveWork });
+  agentKnowledgeService.attachRuntimeBus(runtimeBus);
+  const homeGraphService = new HomeGraphService(homeGraphKnowledgeStore, artifactStore, { semanticService: homeGraphSemanticService, admitExpensiveWork });
+  const projectPlanningProjectId = projectPlanningProjectIdFromPath(deps.workingDirectory);
+  const projectPlanningService = new ProjectPlanningService(knowledgeStore, { defaultProjectId: projectPlanningProjectId });
+  const workPlanStore = new WorkPlanStore({ homeDirectory: deps.homeDirectory, projectId: projectPlanningProjectId, projectRoot: deps.workingDirectory });
+  return {
+    knowledgeStore, agentKnowledgeStore, homeGraphKnowledgeStore,
+    knowledgeSemanticService, homeGraphSemanticService, agentKnowledgeSemanticService,
+    knowledgeService, agentKnowledgeService, homeGraphService,
+    projectPlanningService, projectPlanningProjectId, workPlanStore,
+  };
+}

package/src/runtime/legacy-daemon-migration.ts

@@ -41,7 +41,7 @@
  *     exercised deterministically via fakes and never touches a real running
  *     service in tests.
  */
-import { existsSync, rmSync } from 'node:fs';
+import { existsSync, readFileSync, rmSync } from 'node:fs';
 import { spawnSync } from 'node:child_process';
 import net from 'node:net';
 import { basename, dirname, join } from 'node:path';
@@ -118,12 +118,22 @@ export function buildManagedDaemonServiceManager(params: BuildManagedDaemonServi
     homeDir: params.homeDir,
     surfaceRoot: 'tui',
   });
+  // The unit's ExecStart deliberately carries NO endpoint flags
+  // (--hostname/--port): the daemon resolves controlPlane.hostMode/host/port
+  // from the user's settings at boot, so a later config change (or a host
+  // already configured for hostMode=network / a non-default port) keeps its
+  // endpoint without a unit rewrite. Baking endpoint values here is what
+  // silently re-pinned custom-configured hosts back to the values current at
+  // install time. scripts/install.sh writes the same shape — the two paths
+  // must produce the identical running daemon (see the installer parity test).
+  // `params.host`/`params.port` remain inputs because the migration engine
+  // still needs them for its read-only port-liveness probe.
   const definition: ManagedServiceDefinition = {
     name: MANAGED_SERVICE_NAME,
     description: MANAGED_SERVICE_DESCRIPTION,
     workingDirectory,
     command: params.binaryPath,
-    args: ['--daemon-home', params.homeDir, '--hostname', params.host, '--port', String(params.port)],
+    args: ['--daemon-home', params.homeDir],
     env: {},
     restartOnFailure: true,
   };
@@ -217,8 +227,7 @@ export function detectLegacyUnit(input: DetectLegacyUnitInput): LegacyUnitInfo {
   const path = legacyUnitPath(input.homeDir);
   const fileExists = input.legacyUnitFileExists ?? existsSync;
   if (!fileExists(path)) return { present: false, active: false, path };
-  const run: ManagedServiceActionRunner = input.actionRunner
-    ?? ((command, args) => spawnSync(command, args, { stdio: 'pipe', encoding: 'utf-8' }) as ManagedServiceActionResult);
+  const run: ManagedServiceActionRunner = input.actionRunner ?? defaultActionRunner(SYSTEMCTL_TIMEOUT_MS);
   const result = run('systemctl', ['--user', 'is-active', `${LEGACY_SERVICE_UNIT_NAME}.service`]);
   const state = (result.stdout ?? '').trim();
   const active = (result.status ?? 1) === 0 && state === 'active';
@@ -270,6 +279,30 @@ export function legacyUnitNote(legacy: LegacyUnitInfo, trackedServiceName: strin
   );
 }
 
+/**
+ * Hard ceiling on every systemctl invocation made through a DEFAULT action
+ * runner in this module. The reconcile below runs on the daemon's own startup
+ * path, and `spawnSync` without a timeout blocks the single JS event loop for
+ * as long as the child runs — a wedged user D-Bus (a real incident class on
+ * this host) would freeze an already-listening daemon indefinitely. A timed-out
+ * call reports `status: null`, which every status check in this module treats
+ * as failure, so a wedge degrades to an honest refusal instead of a hang.
+ */
+export const SYSTEMCTL_TIMEOUT_MS = 5_000;
+
+export function defaultActionRunner(timeoutMs: number): ManagedServiceActionRunner {
+  return (command, args) =>
+    spawnSync(command, args, { stdio: 'pipe', encoding: 'utf-8', timeout: timeoutMs }) as ManagedServiceActionResult;
+}
+
+/** Parse a `systemctl show -p MainPID --value` reply: a positive integer pid, or undefined when absent/unparseable/0. */
+export function parseMainPid(result: { status?: number | null; stdout?: string | null | undefined }): number | undefined {
+  if ((result.status ?? 1) !== 0) return undefined;
+  const parsed = Number.parseInt((result.stdout ?? '').trim(), 10);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
+
+
 /**
  * Read-only, best-effort TCP connect probe used ONLY by the legacy-absent
  * branch to tell "nothing is listening on this port" apart from "an
@@ -490,8 +523,7 @@ export async function runLegacyDaemonMigration(
   }
 
   // New unit verified healthy — now, and only now, retire the legacy unit.
-  const run: ManagedServiceActionRunner = params.actionRunner
-    ?? ((command, args) => spawnSync(command, args, { stdio: 'pipe', encoding: 'utf-8' }) as ManagedServiceActionResult);
+  const run: ManagedServiceActionRunner = params.actionRunner ?? defaultActionRunner(SYSTEMCTL_TIMEOUT_MS);
   const stopResult = run('systemctl', ['--user', 'stop', `${LEGACY_SERVICE_UNIT_NAME}.service`]);
   const disableResult = run('systemctl', ['--user', 'disable', `${LEGACY_SERVICE_UNIT_NAME}.service`]);
   const removeFile = params.legacyUnitFileRemove ?? ((path: string) => rmSync(path, { force: true }));