@pellux/goodvibes-agent 0.1.0

package/src/input/commands/recall-capture.ts

@@ -0,0 +1,152 @@
+import type { CommandContext } from '../command-registry.ts';
+import type { ProvenanceLink } from '@pellux/goodvibes-sdk/platform/state';
+import {
+  buildIncidentMemoryAddOptions,
+  buildMcpSecurityMemoryAddOptions,
+  buildPluginSecurityMemoryAddOptions,
+  buildPolicyPreflightMemoryAddOptions,
+} from '@pellux/goodvibes-sdk/platform/state';
+import { VALID_CLASSES, VALID_SCOPES, isValidClass, isValidScope } from './recall-shared.ts';
+import { getMemoryApi } from './recall-query.ts';
+
+export async function handleRecallAdd(args: string[], context: CommandContext): Promise<void> {
+  const memory = getMemoryApi(context);
+  if (!memory) {
+    return;
+  }
+
+  const cls = args[0];
+  if (!cls || !isValidClass(cls)) {
+    context.print(`[recall] Invalid class "${cls ?? ''}". Valid: ${VALID_CLASSES.join(', ')}`);
+    return;
+  }
+
+  const flagArgs = args.slice(1);
+  const detailIdx = flagArgs.indexOf('--detail');
+  const tagsIdx = flagArgs.indexOf('--tags');
+  const sessionIdx = flagArgs.indexOf('--session');
+  const taskIdx = flagArgs.indexOf('--task');
+  const fileIdx = flagArgs.indexOf('--file');
+  const scopeIdx = flagArgs.indexOf('--scope');
+
+  const detail = detailIdx !== -1 ? flagArgs[detailIdx + 1] : undefined;
+  const tagsRaw = tagsIdx !== -1 ? flagArgs[tagsIdx + 1] : undefined;
+  const scopeRaw = scopeIdx !== -1 ? flagArgs[scopeIdx + 1] : undefined;
+  const tags = tagsRaw ? tagsRaw.split(',').map((token) => token.trim()).filter(Boolean) : [];
+  const scope = scopeRaw && isValidScope(scopeRaw) ? scopeRaw : 'project';
+
+  if (scopeRaw && !isValidScope(scopeRaw)) {
+    context.print(`[recall] Invalid scope "${scopeRaw}". Valid: ${VALID_SCOPES.join(', ')}`);
+    return;
+  }
+
+  const provenance: ProvenanceLink[] = [];
+  if (sessionIdx !== -1 && flagArgs[sessionIdx + 1]) provenance.push({ kind: 'session', ref: flagArgs[sessionIdx + 1] });
+  if (taskIdx !== -1 && flagArgs[taskIdx + 1]) provenance.push({ kind: 'task', ref: flagArgs[taskIdx + 1] });
+  if (fileIdx !== -1 && flagArgs[fileIdx + 1]) provenance.push({ kind: 'file', ref: flagArgs[fileIdx + 1] });
+  if (!provenance.some((entry) => entry.kind === 'session') && context.session.runtime.sessionId) {
+    provenance.push({ kind: 'session', ref: context.session.runtime.sessionId });
+  }
+
+  const summaryTokens: string[] = [];
+  for (const token of flagArgs) {
+    if (token.startsWith('--')) break;
+    summaryTokens.push(token);
+  }
+  const summary = summaryTokens.join(' ');
+  if (!summary.trim()) {
+    context.print('[recall] Usage: /recall add <class> <summary> [--detail <text>] [--tags <t1,t2>]');
+    return;
+  }
+
+  const record = await memory.add({ scope, cls, summary, detail, tags, provenance });
+  context.print(`[recall] Added ${cls}: ${record.id}`);
+  context.print(`  Scope:   ${record.scope}`);
+  context.print(`  Summary: ${record.summary}`);
+  if (record.tags.length) context.print(`  Tags: ${record.tags.join(', ')}`);
+  if (record.provenance.length) {
+    context.print(`  Provenance: ${record.provenance.map((entry) => `${entry.kind}:${entry.ref}`).join(', ')}`);
+  }
+}
+
+export async function handleRecallCapture(args: string[], context: CommandContext): Promise<void> {
+  const memory = getMemoryApi(context);
+  const pluginManager = context.extensions.pluginManager;
+  if (!memory) {
+    return;
+  }
+  if (!context.extensions.forensicsRegistry) {
+    context.print('[recall] Forensics registry not available.');
+    return;
+  }
+
+  const target = args[0];
+  if (target === 'incident') {
+    const requestedId = args[1];
+    const report = !requestedId || requestedId === 'latest'
+      ? context.extensions.forensicsRegistry.latest()
+      : context.extensions.forensicsRegistry.getById(requestedId);
+    if (!report) {
+      context.print(`[recall] Incident not found: ${requestedId ?? 'latest'}`);
+      return;
+    }
+    const bundle = context.extensions.forensicsRegistry.buildBundle(report.id);
+    if (!bundle) {
+      context.print(`[recall] Failed to build incident bundle: ${report.id}`);
+      return;
+    }
+    const record = await memory.add(buildIncidentMemoryAddOptions(bundle));
+    context.print(`[recall] Captured incident ${report.id} into memory as ${record.id}`);
+    return;
+  }
+
+  if (target === 'policy') {
+    const review = context.extensions.policyRuntimeState?.getSnapshot().lastPreflightReview;
+    if (!review) {
+      context.print('[recall] No policy preflight review is available to capture.');
+      return;
+    }
+    const record = await memory.add(buildPolicyPreflightMemoryAddOptions(review));
+    context.print(`[recall] Captured policy preflight into memory as ${record.id}`);
+    return;
+  }
+
+  if (target === 'mcp') {
+    const serverName = args[1];
+    if (!serverName) {
+      context.print('[recall] Usage: /recall capture mcp <server>');
+      return;
+    }
+    const server = context.extensions.mcpRegistry.listServerSecurity().find((entry) => entry.name === serverName);
+    if (!server) {
+      context.print(`[recall] MCP server not found: ${serverName}`);
+      return;
+    }
+    const record = await memory.add(buildMcpSecurityMemoryAddOptions(server));
+    context.print(`[recall] Captured MCP server ${server.name} into memory as ${record.id}`);
+    return;
+  }
+
+  if (target === 'plugin') {
+    if (!pluginManager) {
+      context.print('[recall] Plugin manager not available.');
+      return;
+    }
+    const pluginName = args[1];
+    if (!pluginName) {
+      context.print('[recall] Usage: /recall capture plugin <name>');
+      return;
+    }
+    const plugin = pluginManager.list().find((entry) => entry.name === pluginName);
+    if (!plugin) {
+      context.print(`[recall] Plugin not found: ${pluginName}`);
+      return;
+    }
+    const quarantineReason = pluginManager.getQuarantineRecord(plugin.name)?.reason;
+    const record = await memory.add(buildPluginSecurityMemoryAddOptions(plugin, quarantineReason));
+    context.print(`[recall] Captured plugin ${plugin.name} into memory as ${record.id}`);
+    return;
+  }
+
+  context.print('[recall] Usage: /recall capture incident <id|latest> | /recall capture policy | /recall capture mcp <server> | /recall capture plugin <name>');
+}

package/src/input/commands/recall-query.ts

@@ -0,0 +1,229 @@
+import type { CommandContext } from '../command-registry.ts';
+import type { MemoryApi } from '@pellux/goodvibes-sdk/platform/knowledge';
+import type { MemorySearchFilter } from '@pellux/goodvibes-sdk/platform/state';
+import { VALID_CLASSES, VALID_SCOPES, isValidClass, isValidScope } from './recall-shared.ts';
+
+export function getMemoryApi(context: CommandContext): MemoryApi | null {
+  const memoryApi = context.clients?.knowledgeApi?.memory;
+  if (!memoryApi) {
+    context.print('[recall] Memory API is not available in this runtime.');
+    return null;
+  }
+  return memoryApi;
+}
+
+export function handleRecallSearch(args: string[], context: CommandContext): void {
+  const memory = getMemoryApi(context);
+  if (!memory) {
+    return;
+  }
+
+  const clsIdx = args.indexOf('--cls');
+  const limitIdx = args.indexOf('--limit');
+  const semantic = args.includes('--semantic') || args.includes('--vector');
+  const filter: MemorySearchFilter = {};
+
+  if (clsIdx !== -1 && args[clsIdx + 1]) {
+    const cls = args[clsIdx + 1];
+    if (isValidClass(cls)) filter.cls = cls;
+    else {
+      context.print(`[recall] Unknown class "${cls}". Valid: ${VALID_CLASSES.join(', ')}`);
+      return;
+    }
+  }
+
+  const scopeIdx = args.indexOf('--scope');
+  if (scopeIdx !== -1 && args[scopeIdx + 1]) {
+    const scope = args[scopeIdx + 1];
+    if (isValidScope(scope)) filter.scope = scope;
+    else {
+      context.print(`[recall] Unknown scope "${scope}". Valid: ${VALID_SCOPES.join(', ')}`);
+      return;
+    }
+  }
+
+  if (limitIdx !== -1 && args[limitIdx + 1]) {
+    filter.limit = parseInt(args[limitIdx + 1], 10) || 20;
+  }
+
+  const queryTokens = args.filter((token, index) => {
+    if (token.startsWith('--')) return false;
+    if (index > 0 && ['--cls', '--limit', '--scope'].includes(args[index - 1]!)) return false;
+    return true;
+  });
+  if (queryTokens.length) filter.query = queryTokens.join(' ');
+  if (semantic) filter.semantic = true;
+
+  const semanticResults = semantic ? memory.searchSemantic(filter) : [];
+  const results = semantic ? semanticResults.map((entry) => entry.record) : memory.search(filter);
+  if (!results.length) {
+    context.print('[recall] No records found.');
+    return;
+  }
+
+  context.print(`[recall] ${results.length} ${semantic ? 'semantic ' : ''}record(s):`);
+  for (const record of results) {
+    const semanticEntry = semanticResults.find((entry) => entry.record.id === record.id);
+    const ts = new Date(record.createdAt).toISOString().slice(0, 16).replace('T', ' ');
+    const tagStr = record.tags.length ? ` [${record.tags.join(', ')}]` : '';
+    const scoreStr = semanticEntry ? `  sim ${Math.round(semanticEntry.similarity * 100)}%` : '';
+    context.print(`  ${record.id}  [${record.cls}]${tagStr}  ${ts}${scoreStr}`);
+    context.print(`    ${record.summary}`);
+    if (record.provenance.length) {
+      context.print(`    via: ${record.provenance.map((entry) => `${entry.kind}:${entry.ref}`).join(', ')}`);
+    }
+  }
+}
+
+export function handleRecallVector(args: string[], context: CommandContext): void {
+  const memory = getMemoryApi(context);
+  if (!memory) {
+    return;
+  }
+
+  const sub = (args[0] ?? 'status').toLowerCase();
+  if (sub === 'rebuild') {
+    const stats = memory.rebuildVectors();
+    context.print(formatVectorStats(stats, 'rebuild complete'));
+    return;
+  }
+  if (sub === 'status' || sub === 'doctor') {
+    context.print(formatVectorStats(memory.vectorStats(), sub));
+    return;
+  }
+  context.print('[recall] Usage: /recall vector [status|doctor|rebuild]');
+}
+
+function formatVectorStats(
+  stats: ReturnType<MemoryApi['vectorStats']>,
+  label: string,
+): string {
+  return [
+    `[recall] Vector index ${label}`,
+    `  backend: ${stats.backend}`,
+    `  enabled: ${stats.enabled ? 'yes' : 'no'}`,
+    `  available: ${stats.available ? 'yes' : 'no'}`,
+    `  dimensions: ${stats.dimensions}`,
+    `  indexed records: ${stats.indexedRecords}`,
+    ...(stats.path ? [`  path: ${stats.path}`] : []),
+    ...(stats.error ? [`  error: ${stats.error}`] : []),
+  ].join('\n');
+}
+
+export function handleRecallGet(args: string[], context: CommandContext): void {
+  const memory = getMemoryApi(context);
+  if (!memory) {
+    return;
+  }
+  const id = args[0];
+  if (!id) {
+    context.print('[recall] Usage: /recall get <id>');
+    return;
+  }
+  const record = memory.get(id);
+  if (!record) {
+    context.print(`[recall] Record not found: ${id}`);
+    return;
+  }
+  const ts = new Date(record.createdAt).toISOString().slice(0, 19).replace('T', ' ');
+  context.print(`[recall] ${record.id}`);
+  context.print(`  Scope:   ${record.scope}`);
+  context.print(`  Class:   ${record.cls}`);
+  context.print(`  Summary: ${record.summary}`);
+  if (record.detail) context.print(`  Detail:  ${record.detail}`);
+  if (record.tags.length) context.print(`  Tags:    ${record.tags.join(', ')}`);
+  context.print(`  Created: ${ts}`);
+
+  if (record.provenance.length) {
+    context.print('  Provenance:');
+    for (const provenance of record.provenance) {
+      const label = provenance.label ? ` (${provenance.label})` : '';
+      context.print(`    ${provenance.kind}: ${provenance.ref}${label}`);
+    }
+  }
+
+  const links = memory.linksFor(id);
+  if (links.length) {
+    context.print('  Links:');
+    for (const link of links) {
+      const dir = link.fromId === id ? '->' : '<-';
+      const other = link.fromId === id ? link.toId : link.fromId;
+      context.print(`    ${dir} ${other}  [${link.relation}]`);
+    }
+  }
+}
+
+export async function handleRecallLink(args: string[], context: CommandContext): Promise<void> {
+  const memory = getMemoryApi(context);
+  if (!memory) {
+    return;
+  }
+  const [fromId, toId, relation] = args;
+  if (!fromId || !toId || !relation) {
+    context.print('[recall] Usage: /recall link <fromId> <toId> <relation>');
+    return;
+  }
+  const link = await memory.link(fromId, toId, relation);
+  if (!link) {
+    context.print('[recall] Link failed — check that both IDs exist.');
+    return;
+  }
+  context.print(`[recall] Linked: ${fromId} -> ${toId} [${relation}]`);
+}
+
+export function handleRecallRemove(args: string[], context: CommandContext): void {
+  const memory = getMemoryApi(context);
+  if (!memory) {
+    return;
+  }
+  const id = args[0];
+  if (!id) {
+    context.print('[recall] Usage: /recall remove <id>');
+    return;
+  }
+  const removed = memory.delete(id);
+  if (!removed) {
+    context.print(`[recall] Record not found: ${id}`);
+    return;
+  }
+  context.print(`[recall] Deleted: ${id}`);
+}
+
+export function handleRecallList(args: string[], context: CommandContext): void {
+  const memory = getMemoryApi(context);
+  if (!memory) {
+    return;
+  }
+  const cls = args.find((arg) => !arg.startsWith('--'));
+  const filter: MemorySearchFilter = { limit: 50 };
+  if (cls && isValidClass(cls)) filter.cls = cls;
+  const scopeIdx = args.indexOf('--scope');
+  if (scopeIdx !== -1 && args[scopeIdx + 1]) {
+    const scope = args[scopeIdx + 1];
+    if (!isValidScope(scope)) {
+      context.print(`[recall] Unknown scope "${scope}". Valid: ${VALID_SCOPES.join(', ')}`);
+      return;
+    }
+    filter.scope = scope;
+  }
+
+  const records = memory.search(filter);
+  if (!records.length) {
+    context.print('[recall] No records.');
+    return;
+  }
+
+  const grouped: Record<string, Array<(typeof records)[number]>> = {};
+  for (const record of records) {
+    if (!grouped[record.cls]) grouped[record.cls] = [];
+    grouped[record.cls].push(record);
+  }
+
+  for (const [clsName, group] of Object.entries(grouped)) {
+    context.print(`\n[recall] ${clsName.toUpperCase()} (${group.length}):`);
+    for (const record of group) {
+      const tagStr = record.tags.length ? ` [${record.tags.join(', ')}]` : '';
+      context.print(`  ${record.id} [${record.scope}]${tagStr}  ${record.summary}`);
+    }
+  }
+}

package/src/input/commands/recall-review.ts

@@ -0,0 +1,98 @@
+import type { CommandContext } from '../command-registry.ts';
+import { VALID_REVIEW_STATES, VALID_SCOPES, isValidReviewState, isValidScope } from './recall-shared.ts';
+import { getMemoryApi } from './recall-query.ts';
+
+export function handleRecallQueue(args: string[], context: CommandContext): void {
+  const memory = getMemoryApi(context);
+  if (!memory) {
+    return;
+  }
+  const limit = Math.max(1, parseInt(args[0] ?? '10', 10) || 10);
+  const queue = memory.reviewQueue(limit);
+  if (!queue.length) {
+    context.print('[recall] Review queue is empty.');
+    return;
+  }
+  context.print(`[recall] Review queue (${queue.length}):`);
+  for (const record of queue) {
+    const reason = record.staleReason ? ` — ${record.staleReason}` : '';
+    context.print(`  ${record.id} [${record.scope}/${record.cls}] ${record.reviewState} ${record.confidence}%  ${record.summary}${reason}`);
+  }
+}
+
+export function handleRecallReview(args: string[], context: CommandContext): void {
+  const memory = getMemoryApi(context);
+  if (!memory) {
+    return;
+  }
+
+  const [id, stateRaw, ...rest] = args;
+  if (!id || !stateRaw || !isValidReviewState(stateRaw)) {
+    context.print(`[recall] Usage: /recall review <id> <${VALID_REVIEW_STATES.join('|')}> [--confidence <0-100>] [--by <name>] [--reason <text>]`);
+    return;
+  }
+
+  const confidenceIdx = rest.indexOf('--confidence');
+  const byIdx = rest.indexOf('--by');
+  const reasonIdx = rest.indexOf('--reason');
+  const confidence = confidenceIdx !== -1 ? parseInt(rest[confidenceIdx + 1] ?? '', 10) : undefined;
+  const reviewedBy = byIdx !== -1 ? rest[byIdx + 1] : 'operator';
+  const staleReason = reasonIdx !== -1 ? rest.slice(reasonIdx + 1).join(' ') : undefined;
+
+  const record = memory.review(id, {
+    state: stateRaw,
+    confidence: Number.isFinite(confidence) ? confidence : undefined,
+    reviewedBy,
+    staleReason,
+  });
+
+  if (!record) {
+    context.print(`[recall] Record not found: ${id}`);
+    return;
+  }
+  context.print(`[recall] Reviewed ${record.id}: ${record.reviewState} ${record.confidence}%`);
+}
+
+export function handleRecallExplain(args: string[], context: CommandContext): void {
+  const memory = getMemoryApi(context);
+  if (!memory) {
+    return;
+  }
+  const scopeIdx = args.indexOf('--scope');
+  const scopeValues = scopeIdx !== -1 ? args.slice(scopeIdx + 1).filter((token) => !token.startsWith('--')) : [];
+  const taskTokens = args.filter((token, index) => {
+    if (token === '--scope') return false;
+    if (scopeIdx !== -1 && index > scopeIdx) return false;
+    return true;
+  });
+  const task = taskTokens.join(' ').trim();
+  if (!task) {
+    context.print('[recall] Usage: /recall explain <task description...> [--scope <write-scope> ...]');
+    return;
+  }
+  const explanation = memory.explain(task, scopeValues);
+  if (explanation.injections.length === 0) {
+    context.print('[recall] No reviewed project knowledge was selected for that task.');
+    return;
+  }
+  context.print(explanation.prompt ?? '[recall] No explainable project knowledge was selected.');
+}
+
+export function handleRecallPromote(args: string[], context: CommandContext): void {
+  const memory = getMemoryApi(context);
+  if (!memory) {
+    return;
+  }
+  const id = args[0];
+  const scope = args[1];
+  if (!id || !scope || !isValidScope(scope)) {
+    context.print(`[recall] Usage: /recall promote <id> <${VALID_SCOPES.join('|')}>`);
+    return;
+  }
+  const record = memory.update(id, { scope });
+  if (!record) {
+    context.print(`[recall] Record not found: ${id}`);
+    return;
+  }
+  context.print(`[recall] Promoted ${record.id} to ${record.scope} scope.`);
+}

package/src/input/commands/recall-shared.ts

@@ -0,0 +1,22 @@
+import type { ShellPathService } from '@/runtime/index.ts';
+import type { MemoryClass, MemoryReviewState, MemoryScope } from '@pellux/goodvibes-sdk/platform/state';
+
+export const VALID_CLASSES: MemoryClass[] = ['decision', 'constraint', 'incident', 'pattern', 'fact', 'risk', 'runbook', 'architecture', 'ownership'];
+export const VALID_SCOPES: MemoryScope[] = ['session', 'project', 'team'];
+export const VALID_REVIEW_STATES: MemoryReviewState[] = ['fresh', 'reviewed', 'stale', 'contradicted'];
+
+export function isValidClass(s: string): s is MemoryClass {
+  return VALID_CLASSES.includes(s as MemoryClass);
+}
+
+export function isValidScope(s: string): s is MemoryScope {
+  return VALID_SCOPES.includes(s as MemoryScope);
+}
+
+export function isValidReviewState(s: string): s is MemoryReviewState {
+  return VALID_REVIEW_STATES.includes(s as MemoryReviewState);
+}
+
+export function resolveBundlePath(pathArg: string, shellPaths: ShellPathService): string {
+  return shellPaths.resolveWorkspacePath(pathArg);
+}

package/src/input/commands/remote-runtime-pool.ts

@@ -0,0 +1,106 @@
+import type { CommandContext } from '../command-registry.ts';
+
+type RemotePoolLike = {
+  id: string;
+  label: string;
+  trustClass: string;
+  preferredTemplate?: string;
+  maxRunners?: number;
+  runnerIds: readonly string[];
+  description?: string;
+};
+
+type RemoteRegistryLike = {
+  listPools(): readonly RemotePoolLike[];
+  getPool(id: string): RemotePoolLike | null | undefined;
+  createPool(input: { id: string; label: string }): RemotePoolLike;
+  assignRunnerToPool(poolId: string, runnerId: string): RemotePoolLike | null | undefined;
+  removeRunnerFromPool(poolId: string, runnerId: string): RemotePoolLike | null | undefined;
+};
+
+export function handleRemotePoolCommand(
+  args: string[],
+  ctx: Pick<CommandContext, 'print'>,
+  remoteRegistry: RemoteRegistryLike,
+): boolean {
+  const subcommand = args[0]?.toLowerCase() ?? 'show';
+  if (subcommand !== 'pool') return false;
+  const mode = args[1]?.toLowerCase() ?? 'list';
+  if (mode === 'list') {
+    const pools = remoteRegistry.listPools();
+    if (pools.length === 0) {
+      ctx.print('No remote runner pools defined yet.');
+      return true;
+    }
+    ctx.print([
+      `Remote Runner Pools (${pools.length})`,
+      ...pools.map((pool) => `  ${pool.id}  ${pool.runnerIds.length} runners  trust=${pool.trustClass}  template=${pool.preferredTemplate ?? '(none)'}`),
+    ].join('\n'));
+    return true;
+  }
+  if (mode === 'show') {
+    const poolId = args[2];
+    if (!poolId) {
+      ctx.print('Usage: /remote pool show <poolId>');
+      return true;
+    }
+    const pool = remoteRegistry.getPool(poolId);
+    if (!pool) {
+      ctx.print(`Unknown remote runner pool: ${poolId}`);
+      return true;
+    }
+    ctx.print([
+      `Remote Runner Pool ${pool.id}`,
+      `  label: ${pool.label}`,
+      `  trustClass: ${pool.trustClass}`,
+      `  preferredTemplate: ${pool.preferredTemplate ?? '(none)'}`,
+      `  maxRunners: ${pool.maxRunners ?? '(unbounded)'}`,
+      `  runners: ${pool.runnerIds.join(', ') || '(none)'}`,
+      `  description: ${pool.description ?? '(none)'}`,
+    ].join('\n'));
+    return true;
+  }
+  if (mode === 'create') {
+    const poolId = args[2];
+    if (!poolId) {
+      ctx.print('Usage: /remote pool create <poolId> [label]');
+      return true;
+    }
+    const label = args.slice(3).join(' ').trim() || poolId;
+    const pool = remoteRegistry.createPool({ id: poolId, label });
+    ctx.print(`Created remote runner pool ${pool.id} (${pool.label}).`);
+    return true;
+  }
+  if (mode === 'assign') {
+    const poolId = args[2];
+    const runnerId = args[3];
+    if (!poolId || !runnerId) {
+      ctx.print('Usage: /remote pool assign <poolId> <runnerId>');
+      return true;
+    }
+    const pool = remoteRegistry.assignRunnerToPool(poolId, runnerId);
+    if (!pool) {
+      ctx.print(`Could not assign ${runnerId} to pool ${poolId}.`);
+      return true;
+    }
+    ctx.print(`Assigned remote runner ${runnerId} to pool ${poolId}.`);
+    return true;
+  }
+  if (mode === 'unassign') {
+    const poolId = args[2];
+    const runnerId = args[3];
+    if (!poolId || !runnerId) {
+      ctx.print('Usage: /remote pool unassign <poolId> <runnerId>');
+      return true;
+    }
+    const pool = remoteRegistry.removeRunnerFromPool(poolId, runnerId);
+    if (!pool) {
+      ctx.print(`Unknown remote runner pool: ${poolId}`);
+      return true;
+    }
+    ctx.print(`Removed remote runner ${runnerId} from pool ${poolId}.`);
+    return true;
+  }
+  ctx.print('Usage: /remote pool <list|show|create|assign|unassign> ...');
+  return true;
+}