@pellux/goodvibes-agent 0.1.7 → 0.1.9

package/src/input/commands/session.ts

@@ -1,20 +1,9 @@
 /**
  * /session command handler — Multi-session Orchestration.
  *
- * Implements session and workflow commands:
- *
- *   /session link-task <taskId> [--session <sessionId>] [--depends-on <ref>] [--label <label>]
- *     — Register a task as a global cross-session ref, optionally linking it to a
- *       dependency.
- *
- *   /session handoff <taskId> --to <sessionId> [--session <sessionId>] [--reason <reason>]
- *     — Initiate a task handoff from the current session to another.
- *
- *   /session graph [--session <sessionId>] [--format text|json]
- *     — Display the cross-session task dependency graph.
- *
- *   /session cancel <taskId|--scope session> [--session <sessionId>] [--scope task|subtree|session]
- *     — Cancel tasks with configurable scope semantics.
+ * Implements read-only session graph inspection plus session continuity commands.
+ * Copied local task graph mutation commands are blocked in Agent; explicit
+ * build/fix/review handoff must use `/delegate` so GoodVibes TUI owns execution.
  */
 
 import type { SlashCommand, CommandContext } from '../command-registry.ts';
@@ -72,6 +61,14 @@ function fmtRef(ref: CrossSessionTaskRef): string {
   return `${statusBadge(ref.status)} ${key}${label}  "${ref.title}"`;
 }
 
+function printSessionGraphMutationBlocked(context: CommandContext): void {
+  context.print([
+    '[session] Local cross-session task graph mutation is blocked in GoodVibes Agent.',
+    '[session] Use /session graph for read-only inspection.',
+    '[session] Use /delegate <task> for explicit build/fix/review handoff to GoodVibes TUI.',
+  ].join('\n'));
+}
+
 // ── /session link-task ────────────────────────────────────────────────────────
 
 function handleLinkTask(args: string[], context: CommandContext): void {
@@ -192,7 +189,7 @@ function handleGraph(args: string[], context: CommandContext): void {
     if (filterSession) {
       context.print(`[session] No tasks registered for session ${filterSession.slice(0, 8)}...`);
     } else {
-      context.print('[session] Task graph is empty. Use /session link-task to register tasks.');
+      context.print('[session] Task graph is empty. Local task graph mutation is blocked in Agent; use /delegate for explicit build/fix/review handoff.');
     }
     return;
   }
@@ -324,21 +321,21 @@ function handleCancel(args: string[], context: CommandContext): void {
 export const sessionCommand: SlashCommand = {
   name: 'session',
   aliases: ['sess'],
-  description: 'Multi-session orchestration: link tasks, handoff, view graph, and cancel across sessions.',
+  description: 'Session continuity and read-only cross-session graph inspection.',
   usage: '<subcommand> [args]',
-  argsHint: 'link-task|handoff|graph|cancel',
+  argsHint: 'list|resume|save|graph',
   handler: async (args: string[], context: CommandContext): Promise<void> => {
     const [sub, ...rest] = args;
 
     switch (sub) {
       case 'link-task':
       case 'link':
-        handleLinkTask(rest, context);
+        printSessionGraphMutationBlocked(context);
         break;
 
       case 'handoff':
       case 'ho':
-        handleHandoff(rest, context);
+        printSessionGraphMutationBlocked(context);
         break;
 
       case 'graph':
@@ -347,7 +344,7 @@ export const sessionCommand: SlashCommand = {
         break;
 
       case 'cancel':
-        handleCancel(rest, context);
+        printSessionGraphMutationBlocked(context);
         break;
 
       default: {
@@ -357,14 +354,10 @@ export const sessionCommand: SlashCommand = {
             'Usage: /session <subcommand>',
             '  list | rename <name> | resume <id|name> | fork [name] | save [name] | info [id] | export <id> [format] | search <query> | delete <id>',
             '                                 — Session continuity, export, resume, and pruning',
-            '  link-task <taskId> [--session <sid>] [--depends-on <sid:taskId>] [--label <label>]',
-            '                                 — Register a task in the cross-session graph',
-            '  handoff <taskId> --to <sid>  [--session <sid>] [--reason <reason>]',
-            '                                 — Hand a task off to another session',
             '  graph [--session <sid>] [--format text|json]',
             '                                 — Display the cross-session task dependency graph',
-            '  cancel <taskId> [--scope task|subtree|session] [--session <sid>] [--reason <reason>]',
-            '                                 — Cancel tasks with scoped semantics',
+            '  link-task | handoff | cancel',
+            '                                 — Blocked in Agent; use /delegate for explicit build/fix/review handoff',
           ].join('\n');
           context.print(usage);
         }

package/src/input/commands/tasks-runtime.ts

@@ -1,8 +1,28 @@
 import type { CommandRegistry } from '../command-registry.ts';
 import type { RuntimeTask, TaskLifecycleState } from '@/runtime/index.ts';
 import { reviewWorktreeAttachments } from '@/runtime/index.ts';
-import { requireOperatorClient, requireOpsApi, requirePanelManager, requireShellPaths } from './runtime-services.ts';
-import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import { requireOperatorClient, requirePanelManager, requireShellPaths } from './runtime-services.ts';
+
+const BLOCKED_TASK_MUTATIONS: ReadonlySet<string> = new Set([
+  'create',
+  'update',
+  'complete',
+  'fail',
+  'cancel',
+  'pause',
+  'resume',
+  'retry',
+]);
+
+function printTaskMutationBlocked(print: (text: string) => void, subcommand: string): void {
+  print([
+    `Task mutation "${subcommand}" is blocked in GoodVibes Agent.`,
+    '  policy: runtime tasks are read-only from the Agent surface; normal work stays in the main conversation.',
+    '  durable tasks: use /workplan for visible planning and task tracking.',
+    '  build/fix/review: use /delegate <task> to hand explicit implementation work to GoodVibes TUI.',
+    '  result: no local runtime task state was changed.',
+  ].join('\n'));
+}
 
 function sortRuntimeTasks(tasks: RuntimeTask[]): RuntimeTask[] {
   const statusOrder: TaskLifecycleState[] = ['running', 'queued', 'blocked', 'failed', 'completed', 'cancelled'];
@@ -32,8 +52,8 @@ export function registerTasksRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
     name: 'tasks',
     aliases: ['task'],
-    description: 'Inspect and control runtime tasks',
-    usage: '[list [status|kind] | show <taskId> | output <taskId> | create <kind> <owner> <title...> | update <taskId> <title|description|result> <value...> | complete <taskId> [result] | fail <taskId> <error...> | cancel <taskId> [note] | pause <taskId> [note] | resume <taskId> [note] | retry <taskId> [note]]',
+    description: 'Inspect runtime tasks without starting or mutating local background work',
+    usage: '[list [status|kind] | show <taskId> | output <taskId>]',
     handler(args, ctx) {
       if (args.length === 0) {
         if (ctx.showPanel) ctx.showPanel('tasks');
@@ -96,7 +116,7 @@ export function registerTasksRuntimeCommands(registry: CommandRegistry): void {
             return worktrees.total > 0
               ? [
                   `  worktrees: ${worktrees.total} tracked (${worktrees.active} active / ${worktrees.paused} paused / ${worktrees.pendingCleanup} cleanup)`,
-                  `  worktree next: /worktree task ${task.id}`,
+                  '  worktree next: open GoodVibes TUI in the target workspace for recovery.',
                 ]
               : [];
           })(),
@@ -125,106 +145,12 @@ export function registerTasksRuntimeCommands(registry: CommandRegistry): void {
         return;
       }
 
-      if (subcommand === 'create') {
-        const opsApi = requireOpsApi(ctx);
-        const kind = args[1];
-        const owner = args[2];
-        const title = args.slice(3).join(' ').trim();
-        if (!kind || !owner || !title) {
-          ctx.print('Usage: /tasks create <kind> <owner> <title...>');
-          return;
-        }
-        const validKinds = new Set(['exec', 'agent', 'acp', 'scheduler', 'daemon', 'mcp', 'plugin', 'integration']);
-        if (!validKinds.has(kind)) {
-          ctx.print(`Unknown task kind: ${kind}`);
-          return;
-        }
-        const task = opsApi.tasks.create({
-          kind: kind as import('@/runtime/index.ts').TaskKind,
-          owner,
-          title,
-          description: title,
-        });
-        ctx.print(`Created task ${task.id} (${task.kind}) for ${task.owner}.`);
-        return;
-      }
-
-      if (subcommand === 'update') {
-        const opsApi = requireOpsApi(ctx);
-        const taskId = args[1];
-        const field = args[2];
-        const value = args.slice(3).join(' ').trim();
-        if (!taskId || !field || !value) {
-          ctx.print('Usage: /tasks update <taskId> <title|description|result> <value...>');
-          return;
-        }
-        if (field !== 'title' && field !== 'description' && field !== 'result') {
-          ctx.print(`Unsupported task update field: ${field}`);
-          return;
-        }
-        opsApi.tasks.update(taskId, field === 'result' ? { result: value } : { [field]: value });
-        ctx.print(`Updated task ${taskId} field ${field}.`);
-        return;
-      }
-
-      if (subcommand === 'complete') {
-        const opsApi = requireOpsApi(ctx);
-        const taskId = args[1];
-        if (!taskId) {
-          ctx.print('Usage: /tasks complete <taskId> [result]');
-          return;
-        }
-        const result = args.slice(2).join(' ').trim() || undefined;
-        opsApi.tasks.complete(taskId, result);
-        ctx.print(`Completed task ${taskId}.`);
-        return;
-      }
-
-      if (subcommand === 'fail') {
-        const opsApi = requireOpsApi(ctx);
-        const taskId = args[1];
-        const errorText = args.slice(2).join(' ').trim();
-        if (!taskId || !errorText) {
-          ctx.print('Usage: /tasks fail <taskId> <error...>');
-          return;
-        }
-        opsApi.tasks.fail(taskId, { error: errorText });
-        ctx.print(`Failed task ${taskId}.`);
+      if (BLOCKED_TASK_MUTATIONS.has(subcommand)) {
+        printTaskMutationBlocked(ctx.print, subcommand);
         return;
       }
 
-      const taskId = args[1];
-      const note = args.slice(2).join(' ').trim() || undefined;
-      if (!taskId) {
-        ctx.print(`Usage: /tasks ${subcommand} <taskId> [note]`);
-        return;
-      }
-      const opsApi = requireOpsApi(ctx);
-      try {
-        switch (subcommand) {
-          case 'cancel':
-            opsApi.tasks.cancel(taskId, note);
-            ctx.print(`Cancelled task ${taskId}.`);
-            return;
-          case 'pause':
-            opsApi.tasks.pause(taskId, note);
-            ctx.print(`Paused task ${taskId}.`);
-            return;
-          case 'resume':
-            opsApi.tasks.resume(taskId, note);
-            ctx.print(`Resumed task ${taskId}.`);
-            return;
-          case 'retry':
-            opsApi.tasks.retry(taskId, note);
-            ctx.print(`Re-queued task ${taskId}.`);
-            return;
-          default:
-            ctx.print(`Unknown tasks subcommand: ${subcommand}`);
-            return;
-        }
-      } catch (error) {
-        ctx.print(summarizeError(error));
-      }
+      ctx.print(`Unknown tasks subcommand: ${subcommand}`);
     },
   });
 }

package/src/input/commands.ts

@@ -57,6 +57,7 @@ import { registerAgentExternalizedTuiCommands } from './commands/agent-externali
 import { registerDelegationRuntimeCommands } from './commands/delegation-runtime.ts';
 import { registerPersonasRuntimeCommands } from './commands/personas-runtime.ts';
 import { registerAgentSkillsRuntimeCommands } from './commands/agent-skills-runtime.ts';
+import { registerRoutinesRuntimeCommands } from './commands/routines-runtime.ts';
 
 /**
  * registerBuiltinCommands - Register all built-in slash commands into the registry.
@@ -67,6 +68,7 @@ export function registerBuiltinCommands(registry: CommandRegistry): void {
   registerAgentWorkspaceRuntimeCommands(registry);
   registerPersonasRuntimeCommands(registry);
   registerAgentSkillsRuntimeCommands(registry);
+  registerRoutinesRuntimeCommands(registry);
   registerDelegationRuntimeCommands(registry);
   registerConfigCommand(registry);
   registerOperatorRuntimeCommands(registry);

package/src/input/handler-picker-routes.ts

@@ -256,7 +256,7 @@ type LiveTailRouteState = {
     active: boolean;
     scrollUp: () => void;
     scrollDown: () => void;
-    killProcess: () => void;
+    killProcess: () => boolean;
     close: () => void;
   };
   processModal: {
@@ -270,8 +270,7 @@ export function handleLiveTailToken(state: LiveTailRouteState, token: InputToken
   if (!state.liveTailModal.active) return false;
 
   const killAndReturn = (): void => {
-    state.liveTailModal.killProcess();
-    state.handleEscape();
+    if (state.liveTailModal.killProcess()) state.handleEscape();
   };
 
   if (token.type === 'key') {

package/src/panels/provider-health-domains.ts

@@ -200,15 +200,15 @@ export function buildProviderHealthDomainSummaries(
     summary: worktreeSummary.total === 0
       ? 'no persisted worktrees'
       : `${worktreeSummary.total} tracked / ${worktreeIssues} need review`,
-    next: worktreeIssues > 0 ? '/worktree recover <session|task> <id>' : '/worktree review',
+    next: 'externalized to GoodVibes TUI',
     details: [
       worktreeSummary.paused > 0 ? `${worktreeSummary.paused} paused worktree(s)` : '',
       worktreeSummary.pendingCleanup > 0 ? `${worktreeSummary.pendingCleanup} cleanup pending` : '',
       worktreeSummary.discard > 0 ? `${worktreeSummary.discard} marked discard` : '',
     ].filter(Boolean),
     nextSteps: worktreeIssues > 0
-      ? ['/worktree review', '/worktree recover <session|task> <id>']
-      : ['/worktree review'],
+      ? ['Open GoodVibes TUI in the target workspace for recovery', '/delegate <task> for explicit build/fix/review recovery']
+      : ['No Agent worktree action available; use GoodVibes TUI when repository recovery is needed'],
   });
 
   return summaries;

package/src/renderer/agent-workspace.ts

@@ -97,9 +97,10 @@ function snapshotLines(category: AgentWorkspaceCategory, snapshot: AgentWorkspac
   } else if (category.id === 'memory') {
     base.push(
       { text: `Session memories: ${snapshot.sessionMemoryCount}`, fg: PALETTE.info },
+      { text: `Local routines: ${snapshot.localRoutineCount}; enabled: ${snapshot.enabledRoutineCount}`, fg: PALETTE.info },
       { text: `Local skills: ${snapshot.localSkillCount}; enabled: ${snapshot.enabledSkillCount}`, fg: PALETTE.info },
       { text: `Local personas: ${snapshot.localPersonaCount}; active: ${snapshot.activePersonaName}`, fg: PALETTE.info },
-      { text: 'Durable memory, skills, and personas remain Agent-local until shared registry contracts exist.', fg: PALETTE.good },
+      { text: 'Durable memory, routines, skills, and personas remain Agent-local until shared registry contracts exist.', fg: PALETTE.good },
       { text: 'Secrets are rejected/redacted; store secret references instead of secret values.', fg: PALETTE.warn },
     );
   } else if (category.id === 'work') {

package/src/renderer/live-tail-modal.ts

@@ -6,7 +6,7 @@ import type { ProcessEntry } from './process-modal.ts';
 import { getOverlaySurfaceMetrics, getStableOverlayContentRows } from './overlay-viewport.ts';
 
 export interface LiveTailModalDeps {
-  readonly agentManager: Pick<AgentManager, 'cancel' | 'getStatus'>;
+  readonly agentManager: Pick<AgentManager, 'getStatus'>;
   readonly processManager: Pick<ProcessManager, 'stop' | 'getOutput'>;
 }
 
@@ -15,7 +15,7 @@ export interface LiveTailModalDeps {
 /**
  * LiveTailModal — manages state for the live output peek modal.
  *
- * Shows streaming stdout/stderr from a selected background process or agent
+ * Shows streaming stdout/stderr from a selected shell process or agent
  * progress notes. Auto-scrolls to the bottom unless the user scrolled up.
  */
 export class LiveTailModal {
@@ -48,17 +48,17 @@ export class LiveTailModal {
   }
 
   /**
-   * Kill the current process.
-   * Returns true if the process was found and stopped.
+   * Stop the current shell process when it is an exec entry.
+   * Agent entries are read-only in GoodVibes Agent; build execution and
+   * cancellation belong to GoodVibes TUI/shared-session owners.
    */
   killProcess(): boolean {
     if (!this.entry) return false;
 
     if (this.entry.type === 'exec') {
       return this.deps.processManager.stop(this.entry.id);
-    } else {
-      return this.deps.agentManager.cancel(this.entry.id);
     }
+    return false;
   }
 
   /** Retrieve the current output text for the watched process. */
@@ -151,6 +151,6 @@ export function renderLiveTailModal(
     margin: 2,
     targetContentRows,
     sections,
-    hints: ['[Up/Down] Scroll', '[k] Kill', '[Esc] Back'],
+    hints: ['[Up/Down] Scroll', '[k] Stop exec only', '[Esc] Back'],
   }, width);
 }

package/src/renderer/process-indicator.ts

@@ -17,12 +17,12 @@ function truncateToWidth(text: string, maxWidth: number): string {
 }
 
 /**
- * renderProcessIndicator — shows a one-line summary of active background
- * processes below the input area.
+ * renderProcessIndicator — shows a one-line summary of active runtime
+ * activity below the input area.
  *
- * Dimmed when no processes are active, highlighted (cyan) when agents or
- * background exec processes are running. Includes an `Enter to view` hint
- * when active.
+ * Dimmed when no entries are active, highlighted (cyan) when delegated work
+ * records or shell exec processes are running. Includes an `Enter to view`
+ * hint when active.
  */
 export function renderProcessIndicator(
   width: number,
@@ -32,6 +32,7 @@ export function renderProcessIndicator(
   agentProgress?: string,
 ): Line[] {
   const total = agentCount + toolCount;
+  const delegationLabel = (count: number): string => `${count} delegation${count !== 1 ? 's' : ''}`;
   const renderPlainStatus = (text: string, style: { fg: string; bold?: boolean; dim?: boolean }): Line[] => (
     [UIFactory.stringToLine(`   ${text}`, width, style)]
   );
@@ -59,30 +60,30 @@ export function renderProcessIndicator(
   // --- Focused state: always render before idle/active branches ---
   if (focused) {
     const parts: string[] = [];
-    if (agentCount > 0) parts.push(`${agentCount} agent${agentCount !== 1 ? 's' : ''}`);
+    if (agentCount > 0) parts.push(delegationLabel(agentCount));
     if (toolCount > 0) parts.push(`${toolCount} tool${toolCount !== 1 ? 's' : ''} running`);
     const label = total === 0
-      ? `No background processes  ${GLYPHS.status.pending}  back to input`
+      ? `No runtime activity  ${GLYPHS.status.pending}  back to input`
       : `${parts.join(` ${GLYPHS.navigation.pipeSeparator} `)}  ${GLYPHS.status.pending}  Enter to open  ${GLYPHS.status.pending}  back to input`;
     return renderFocusedStatus(label);
   }
 
   if (total === 0) {
-    return renderPlainStatus('No background processes', { fg: '238', dim: true });
+    return renderPlainStatus('No runtime activity', { fg: '238', dim: true });
   }
 
-  // Build the label: "bg: 2 agents | Turn 3 | write - src/foo.ts"
+  // Build the label: "2 delegations | Turn 3 | write - src/foo.ts"
   const parts: string[] = [];
   if (agentCount > 0) {
-    parts.push(`${agentCount} agent${agentCount !== 1 ? 's' : ''}`);
+    parts.push(delegationLabel(agentCount));
   }
   if (toolCount > 0) {
     parts.push(`${toolCount} tool${toolCount !== 1 ? 's' : ''} running`);
   }
   // Append the first running agent's progress (truncated to fit)
   /**
-   * Number of columns reserved for the agent count label and hint text.
-   * Breakdown: "bg: N agents" prefix (~15 chars) + " | " separator (~3)
+   * Number of columns reserved for the delegation count label and hint text.
+   * Breakdown: "N delegations" prefix (~15 chars) + " | " separator (~3)
    * + "  Enter to view  " hint (~17) + padding (~8) ≈ 43 chars.
    */
   const PROGRESS_RESERVED_CHARS = 43;

package/src/renderer/process-modal.ts

@@ -42,7 +42,7 @@ const WRFC_ROLE_ORDER: Record<string, number> = {
 };
 
 export interface ProcessModalDeps {
-  readonly agentManager: Pick<AgentManager, 'list' | 'getStatus' | 'cancel'>;
+  readonly agentManager: Pick<AgentManager, 'list' | 'getStatus'>;
   readonly processManager: Pick<ProcessManager, 'list' | 'getStatus' | 'stop'>;
   readonly wrfcController: Pick<WrfcController, 'getChain'> & Partial<Pick<WrfcController, 'listChains'>>;
 }
@@ -558,8 +558,9 @@ export class ProcessModal {
   }
 
   /**
-   * Kill the selected process.
-   * Returns true if a process was killed, false otherwise.
+   * Stop the selected shell process.
+   * Agent entries are read-only in GoodVibes Agent; build execution and
+   * cancellation belong to GoodVibes TUI/shared-session owners.
    */
   killSelected(): boolean {
     const entry = this.getSelected();
@@ -567,9 +568,8 @@ export class ProcessModal {
 
     if (entry.type === 'exec') {
       return this.deps.processManager.stop(entry.id);
-    } else {
-      return this.deps.agentManager.cancel(entry.id);
     }
+    return false;
   }
 }
 
@@ -598,12 +598,12 @@ export function renderProcessModal(modal: ProcessModal, width: number, viewportH
 
   if (modal.entries.length === 0) {
     return ModalFactory.createModal({
-      title: 'Background Processes',
+      title: 'Runtime Activity',
       width: boxW,
       margin: boxMargin,
       targetContentRows,
       sections: [
-        { type: 'text', content: 'No background processes running.' },
+        { type: 'text', content: 'No runtime activity.' },
       ],
       hints: ['[Esc] Close'],
     }, width);
@@ -643,7 +643,7 @@ export function renderProcessModal(modal: ProcessModal, width: number, viewportH
   }
 
   return ModalFactory.createModal({
-    title: 'Background Processes',
+    title: 'Runtime Activity',
     width: boxW,
     margin: boxMargin,
     targetContentRows,
@@ -651,6 +651,6 @@ export function renderProcessModal(modal: ProcessModal, width: number, viewportH
     helpers: modal.entries.length > maxVisibleRows
       ? [{ content: `[${window.start + 1}-${window.end} of ${modal.entries.length}]` }]
       : undefined,
-    hints: ['[Up/Down] Navigate', '[Enter] Peek output', '[k] Kill', '[Esc] Close'],
+    hints: ['[Up/Down] Navigate', '[Enter] Details/output', '[k] Stop exec only', '[Esc] Close'],
   }, width);
 }

package/src/runtime/bootstrap.ts

@@ -44,6 +44,7 @@ import { startMcpConfigAutoReload } from '../mcp/runtime-reload.ts';
 import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
 import { buildActivePersonaPrompt } from '../agent/persona-registry.ts';
 import { buildEnabledSkillsPrompt } from '../agent/skill-registry.ts';
+import { buildEnabledRoutinesPrompt } from '../agent/routine-registry.ts';
 
 const GOODVIBES_AGENT_OPERATOR_POLICY = [
   '## GoodVibes Agent Operator Policy',
@@ -210,6 +211,7 @@ export async function bootstrapRuntime(
       return joinPromptParts(
         runtime.systemPrompt,
         GOODVIBES_AGENT_OPERATOR_POLICY,
+        buildEnabledRoutinesPrompt(services.shellPaths),
         buildEnabledSkillsPrompt(services.shellPaths),
         buildActivePersonaPrompt(services.shellPaths),
         supplement,

package/src/runtime/services.ts

@@ -88,7 +88,6 @@ import {
 } from '@pellux/goodvibes-sdk/platform/tools';
 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';
 
 function buildFallbackModelDefinition(provider: string, modelId: string): ModelDefinition {
@@ -170,6 +169,7 @@ export interface RuntimeServices {
   readonly automationManager: AutomationManager;
   readonly gatewayMethods: GatewayMethodCatalog;
   readonly artifactStore: ArtifactStore;
+  /** Compatibility alias that intentionally points at the isolated Agent Knowledge service, not default Knowledge/Wiki. */
   readonly knowledgeService: KnowledgeService;
   readonly agentKnowledgeService: KnowledgeService;
   readonly homeGraphService: HomeGraphService;
@@ -395,10 +395,6 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
       ].join(' '));
     },
   });
-  const knowledgeStore = new KnowledgeStore({
-    configManager,
-    dbFileName: REGULAR_KNOWLEDGE_DB_FILE,
-  });
   const agentKnowledgeStore = new KnowledgeStore({
     configManager,
     dbFileName: GOODVIBES_AGENT_KNOWLEDGE_DB_FILE,
@@ -411,10 +407,6 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     timeoutMs: 20_000,
     maxConcurrent: 1,
   });
-  const knowledgeSemanticService = new KnowledgeSemanticService(knowledgeStore, {
-    llm: knowledgeSemanticLlm,
-    maxLlmSourcesPerReindex: 3,
-  });
   const homeGraphSemanticService = new KnowledgeSemanticService(homeGraphKnowledgeStore, {
     llm: knowledgeSemanticLlm,
     maxLlmSourcesPerReindex: 3,
@@ -424,12 +416,6 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     llm: knowledgeSemanticLlm,
     maxLlmSourcesPerReindex: 3,
   });
-  const knowledgeService = new KnowledgeService(knowledgeStore, artifactStore, undefined, {
-    memoryRegistry,
-    runtimeBus: options.runtimeBus,
-    semanticService: knowledgeSemanticService,
-  });
-  knowledgeService.attachRuntimeBus(options.runtimeBus);
   const agentKnowledgeService = new KnowledgeService(agentKnowledgeStore, artifactStore, undefined, {
     memoryRegistry,
     runtimeBus: options.runtimeBus,
@@ -459,10 +445,6 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     serviceRegistry,
     featureFlags,
   });
-  knowledgeSemanticService.setGapRepairer(createWebKnowledgeGapRepairer({
-    searchService: webSearchService,
-    ingestService: knowledgeService,
-  }));
   agentKnowledgeSemanticService.setGapRepairer(createWebKnowledgeGapRepairer({
     searchService: webSearchService,
     ingestService: agentKnowledgeService,
@@ -597,7 +579,7 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     automationManager,
     gatewayMethods,
     artifactStore,
-    knowledgeService,
+    knowledgeService: agentKnowledgeService,
     agentKnowledgeService,
     homeGraphService,
     projectPlanningService,

package/src/tools/wrfc-agent-guard.ts

@@ -10,6 +10,20 @@ type AgentToolPolicyGuardOptions = {
   readonly getLastUserMessage?: () => string | null;
 };
 
+const READ_ONLY_AGENT_TOOL_MODES = [
+  'status',
+  'list',
+  'templates',
+  'get',
+  'budget',
+  'wrfc-chains',
+  'wrfc-history',
+  'cohort-status',
+  'cohort-report',
+] as const;
+
+const READ_ONLY_AGENT_TOOL_MODE_SET = new Set<string>(READ_ONLY_AGENT_TOOL_MODES);
+
 const LOCAL_AGENT_DENIAL = [
   'GoodVibes Agent does not spawn local Engineer/Reviewer/Tester/Verifier roots or run local WRFC chains.',
   'Keep ordinary assistant work serial in the main conversation.',
@@ -23,6 +37,7 @@ export function installAgentToolPolicyGuard(registry: ToolRegistry, options: Age
 }
 
 export function wrapAgentToolForAgentPolicy(tool: Tool, _options: AgentToolPolicyGuardOptions = {}): void {
+  narrowAgentToolDefinitionForAgentPolicy(tool);
   const originalExecute = tool.execute.bind(tool);
   tool.execute = async (args) => {
     const denial = validateAgentToolInvocationForAgentPolicy(args as AgentToolArgs);
@@ -32,7 +47,7 @@ export function wrapAgentToolForAgentPolicy(tool: Tool, _options: AgentToolPolic
 }
 
 export function validateAgentToolInvocationForAgentPolicy(args: AgentToolArgs): string | null {
-  if (args.mode === 'spawn' || args.mode === 'batch-spawn') return LOCAL_AGENT_DENIAL;
+  if (typeof args.mode === 'string' && !READ_ONLY_AGENT_TOOL_MODE_SET.has(args.mode)) return LOCAL_AGENT_DENIAL;
   return null;
 }
 
@@ -41,6 +56,27 @@ export function normalizeAgentToolInvocationForAgentPolicy(args: AgentToolArgs):
 }
 
 export const AGENT_LOCAL_SPAWN_DENIAL_MESSAGE = LOCAL_AGENT_DENIAL;
+export const AGENT_READ_ONLY_TOOL_MODES = READ_ONLY_AGENT_TOOL_MODES;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function narrowAgentToolDefinitionForAgentPolicy(tool: Tool): void {
+  tool.definition.description = [
+    'Read-only local Agent inspection for GoodVibes Agent.',
+    'This product does not spawn local worker agents or run local WRFC chains.',
+    'For build/fix/review work, delegate to GoodVibes TUI through the explicit build-delegation path instead.',
+  ].join(' ');
+  tool.definition.sideEffects = [];
+
+  const properties = tool.definition.parameters.properties;
+  if (!isRecord(properties)) return;
+  const modeProperty = properties.mode;
+  if (!isRecord(modeProperty)) return;
+  modeProperty.enum = [...READ_ONLY_AGENT_TOOL_MODES];
+  modeProperty.description = 'Read-only Agent inspection mode. Local spawn, batch-spawn, cancel, message, wait, and plan modes are disabled in GoodVibes Agent.';
+}
 
 // Compatibility exports for copied TUI tests/imports during the near-fork phase.
 export const installWrfcAgentToolGuard = installAgentToolPolicyGuard;