@pellux/goodvibes-agent 0.1.6 → 0.1.8

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/builtin/shared.ts

@@ -55,9 +55,9 @@ export interface BuiltinPanelDeps {
   resumeSession?: (sessionId: string) => void;
   /** Request a shell repaint directly rather than routing through a retired event path. */
   requestRender?: () => void;
-  /** Submit a Planning panel answer through the normal TUI chat/planning coordinator path. */
+  /** Submit a Planning panel answer through the normal Agent chat/planning coordinator path. */
   submitPlanningAnswer?: (answer: string) => void;
-  /** Pause the TUI-owned planning loop and return focus to normal prompt input. */
+  /** Pause the Agent-owned planning loop and return focus to normal prompt input. */
   dismissPlanning?: () => void;
   /** ForensicsRegistry for the Forensics panel. */
   forensicsRegistry?: import('@/runtime/index.ts').ForensicsRegistry;
@@ -96,9 +96,9 @@ export interface BuiltinPanelDeps {
   adaptivePlanner?: AdaptivePlanner;
   /** Passive SDK-backed project planning artifact service. */
   projectPlanningService?: ProjectPlanningService;
-  /** Stable workspace project id for project:<projectId> planning spaces. */
+  /** Stable workspace project id for project:<projectId> planning namespaces. */
   projectPlanningProjectId?: string;
-  /** TUI-owned persistent work plan store. */
+  /** Agent-owned persistent work plan store. */
   workPlanStore?: import('../../work-plans/work-plan-store.ts').WorkPlanStore;
   /** Shared system-messages panel instance attached from boot so low-priority chatter stays out of conversation. */
   systemMessagesPanel?: import('../system-messages-panel.ts').SystemMessagesPanel;

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/planning/project-planning-coordinator.ts

@@ -198,7 +198,7 @@ export class ProjectPlanningCoordinator {
       metadata: {
         ...(existing?.metadata ?? {}),
         active: true,
-        owner: 'tui',
+        owner: 'agent',
         source: 'conversation',
         lastPromptAt: now,
       },
@@ -471,13 +471,13 @@ export class ProjectPlanningCoordinator {
       .join('\n') || '- none recorded yet';
 
     return [
-      'TUI-owned project planning loop is active for this turn.',
+      'Agent-owned planning loop is active for this turn.',
       'Do not execute code changes, spawn agents, or claim implementation is complete unless the user explicitly approves execution after the plan is structurally ready.',
       'Be relentless and thorough: challenge vague wording, inspect relevant context before proposing execution, and ask exactly one focused question when information is missing.',
       'Do not ask broad questions like "what is in scope?" without examples. Break broad planning gaps into concrete choices, explain tradeoffs, and recommend a default the user can accept or correct.',
       '',
       `Project id: ${this.projectId}`,
-      `Knowledge space: ${state.knowledgeSpaceId}`,
+      `Planning namespace: ${state.knowledgeSpaceId}`,
       `Readiness: ${evaluation.readiness}`,
       `Execution approved: ${state.executionApproved ? 'yes' : 'no'}`,
       `Goal: ${state.goal || '(missing)'}`,

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 agent
+ * records or shell exec processes are running. Includes an `Enter to view`
+ * hint when active.
  */
 export function renderProcessIndicator(
   width: number,
@@ -62,16 +62,16 @@ export function renderProcessIndicator(
     if (agentCount > 0) parts.push(`${agentCount} agent${agentCount !== 1 ? 's' : ''}`);
     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 agents | Turn 3 | write - src/foo.ts"
   const parts: string[] = [];
   if (agentCount > 0) {
     parts.push(`${agentCount} agent${agentCount !== 1 ? 's' : ''}`);

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,