@pellux/goodvibes-agent 1.1.6 → 1.2.0

package/src/runtime/execution-ledger.ts

@@ -0,0 +1,231 @@
+import type { RuntimeEventBus, ToolEvent } from '@/runtime/index.ts';
+
+export type AgentExecutionStatus = 'running' | 'succeeded' | 'failed' | 'cancelled';
+export type AgentExecutionRouteKind = 'read' | 'write' | 'shell' | 'network' | 'browser' | 'delegation' | 'other';
+
+export interface AgentExecutionResultSummary {
+  readonly kind: string;
+  readonly byteSize: number;
+  readonly preview?: string | undefined;
+}
+
+export interface AgentExecutionRecord {
+  readonly id: string;
+  readonly callId: string;
+  readonly turnId: string;
+  readonly tool: string;
+  readonly routeKind: AgentExecutionRouteKind;
+  readonly status: AgentExecutionStatus;
+  readonly phase: ToolEvent['type'];
+  readonly receivedAt: number;
+  readonly updatedAt: number;
+  readonly completedAt?: number | undefined;
+  readonly durationMs?: number | undefined;
+  readonly permissionApproved?: boolean | undefined;
+  readonly argsPreview: string;
+  readonly argsKeys: readonly string[];
+  readonly commandPreview?: string | undefined;
+  readonly targetPreview?: string | undefined;
+  readonly resultSummary?: AgentExecutionResultSummary | undefined;
+  readonly error?: string | undefined;
+  readonly cancelReason?: string | undefined;
+}
+
+interface MutableAgentExecutionRecord {
+  id: string;
+  callId: string;
+  turnId: string;
+  tool: string;
+  routeKind: AgentExecutionRouteKind;
+  status: AgentExecutionStatus;
+  phase: ToolEvent['type'];
+  receivedAt: number;
+  updatedAt: number;
+  completedAt?: number | undefined;
+  durationMs?: number | undefined;
+  permissionApproved?: boolean | undefined;
+  argsPreview: string;
+  argsKeys: readonly string[];
+  commandPreview?: string | undefined;
+  targetPreview?: string | undefined;
+  resultSummary?: AgentExecutionResultSummary | undefined;
+  error?: string | undefined;
+  cancelReason?: string | undefined;
+}
+
+export interface AgentExecutionLedgerSnapshot {
+  readonly records: readonly AgentExecutionRecord[];
+  readonly total: number;
+  readonly running: number;
+  readonly succeeded: number;
+  readonly failed: number;
+  readonly cancelled: number;
+}
+
+const DEFAULT_LIMIT = 500;
+const SECRET_KEY_PATTERN = /(?:api[_-]?key|authorization|bearer|client[_-]?secret|password|secret|token)/i;
+
+function truncateText(value: string, max = 220): string {
+  const compact = value.replace(/\s+/g, ' ').trim();
+  return compact.length > max ? `${compact.slice(0, Math.max(0, max - 1))}...` : compact;
+}
+
+function redactValue(value: unknown, depth = 0): unknown {
+  if (depth > 3) return '[truncated]';
+  if (typeof value === 'string') return truncateText(value);
+  if (typeof value === 'number' || typeof value === 'boolean' || value === null) return value;
+  if (Array.isArray(value)) return value.slice(0, 8).map((entry) => redactValue(entry, depth + 1));
+  if (!value || typeof value !== 'object') return String(value);
+  const entries = Object.entries(value as Record<string, unknown>).slice(0, 16).map(([key, entry]) => (
+    [key, SECRET_KEY_PATTERN.test(key) ? '[redacted]' : redactValue(entry, depth + 1)] as const
+  ));
+  return Object.fromEntries(entries);
+}
+
+function argsPreview(args: Record<string, unknown>): string {
+  try {
+    return truncateText(JSON.stringify(redactValue(args)), 360);
+  } catch {
+    return '[unserializable args]';
+  }
+}
+
+function stringArg(args: Record<string, unknown>, keys: readonly string[]): string | undefined {
+  for (const key of keys) {
+    const value = args[key];
+    if (typeof value === 'string' && value.trim()) return truncateText(value, 180);
+  }
+  return undefined;
+}
+
+function routeKindForTool(tool: string, args: Record<string, unknown>): AgentExecutionRouteKind {
+  const name = tool.toLowerCase();
+  if (name.includes('browser') || name.includes('desktop') || name.includes('screenshot')) return 'browser';
+  if (name.includes('delegate') || name.includes('agent')) return 'delegation';
+  if (name.includes('exec') || name.includes('shell') || name.includes('bash') || typeof args.command === 'string') return 'shell';
+  if (name.includes('write') || name.includes('edit') || name.includes('patch') || name.includes('delete')) return 'write';
+  if (name.includes('fetch') || name.includes('web') || name.includes('http') || name.includes('url')) return 'network';
+  if (name.includes('read') || name.includes('find') || name.includes('inspect') || name.includes('grep') || name.includes('search')) return 'read';
+  return 'other';
+}
+
+function statusForPhase(phase: ToolEvent['type']): AgentExecutionStatus {
+  if (phase === 'TOOL_SUCCEEDED') return 'succeeded';
+  if (phase === 'TOOL_FAILED') return 'failed';
+  if (phase === 'TOOL_CANCELLED') return 'cancelled';
+  return 'running';
+}
+
+function resultSummaryFrom(value: Extract<ToolEvent, { type: 'TOOL_SUCCEEDED' | 'TOOL_FAILED' }>['result']): AgentExecutionResultSummary | undefined {
+  if (!value) return undefined;
+  return {
+    kind: value.kind,
+    byteSize: value.byteSize,
+    ...(typeof value.preview === 'string' && value.preview.trim() ? { preview: truncateText(value.preview, 220) } : {}),
+  };
+}
+
+function immutable(record: MutableAgentExecutionRecord): AgentExecutionRecord {
+  return { ...record };
+}
+
+export class AgentExecutionLedger {
+  private readonly records = new Map<string, MutableAgentExecutionRecord>();
+  private readonly order: string[] = [];
+  private readonly subscribers = new Set<() => void>();
+  private readonly unsubscribe: () => void;
+
+  public constructor(
+    runtimeBus: RuntimeEventBus,
+    private readonly limit: number = DEFAULT_LIMIT,
+  ) {
+    this.unsubscribe = runtimeBus.onDomain('tools', (envelope) => {
+      this.handleToolEvent(envelope.payload as ToolEvent, envelope.ts);
+    });
+  }
+
+  public getSnapshot(): AgentExecutionLedgerSnapshot {
+    const records = this.order
+      .map((id) => this.records.get(id))
+      .filter((record): record is MutableAgentExecutionRecord => record !== undefined)
+      .map(immutable)
+      .reverse();
+    return {
+      records,
+      total: records.length,
+      running: records.filter((record) => record.status === 'running').length,
+      succeeded: records.filter((record) => record.status === 'succeeded').length,
+      failed: records.filter((record) => record.status === 'failed').length,
+      cancelled: records.filter((record) => record.status === 'cancelled').length,
+    };
+  }
+
+  public subscribe(callback: () => void): () => void {
+    this.subscribers.add(callback);
+    return () => this.subscribers.delete(callback);
+  }
+
+  public dispose(): void {
+    this.unsubscribe();
+    this.subscribers.clear();
+  }
+
+  private handleToolEvent(event: ToolEvent, timestamp: number): void {
+    if (!('callId' in event)) return;
+    if (event.type === 'TOOL_RECEIVED') {
+      this.recordReceived(event, timestamp);
+      return;
+    }
+    const existing = this.records.get(event.callId);
+    if (!existing) return;
+    existing.phase = event.type;
+    existing.status = statusForPhase(event.type);
+    existing.updatedAt = timestamp;
+    if (event.type === 'TOOL_PERMISSIONED') existing.permissionApproved = event.approved;
+    if (event.type === 'TOOL_SUCCEEDED') {
+      existing.completedAt = timestamp;
+      existing.durationMs = event.durationMs;
+      existing.resultSummary = resultSummaryFrom(event.result);
+    }
+    if (event.type === 'TOOL_FAILED') {
+      existing.completedAt = timestamp;
+      existing.durationMs = event.durationMs;
+      existing.error = truncateText(event.error, 220);
+      existing.resultSummary = resultSummaryFrom(event.result);
+    }
+    if (event.type === 'TOOL_CANCELLED') {
+      existing.completedAt = timestamp;
+      existing.cancelReason = event.reason ? truncateText(event.reason, 220) : undefined;
+    }
+    this.notify();
+  }
+
+  private recordReceived(event: Extract<ToolEvent, { type: 'TOOL_RECEIVED' }>, timestamp: number): void {
+    const record: MutableAgentExecutionRecord = {
+      id: event.callId,
+      callId: event.callId,
+      turnId: event.turnId,
+      tool: event.tool,
+      routeKind: routeKindForTool(event.tool, event.args),
+      status: 'running',
+      phase: event.type,
+      receivedAt: timestamp,
+      updatedAt: timestamp,
+      argsPreview: argsPreview(event.args),
+      argsKeys: Object.keys(event.args).filter((key) => !SECRET_KEY_PATTERN.test(key)).sort(),
+      commandPreview: stringArg(event.args, ['command', 'cmd', 'script']),
+      targetPreview: stringArg(event.args, ['path', 'file', 'target', 'url', 'query', 'task']),
+    };
+    this.records.set(record.id, record);
+    this.order.push(record.id);
+    while (this.order.length > this.limit) {
+      const dropped = this.order.shift();
+      if (dropped) this.records.delete(dropped);
+    }
+    this.notify();
+  }
+
+  private notify(): void {
+    for (const callback of this.subscribers) callback();
+  }
+}

package/src/runtime/services.ts

@@ -9,6 +9,7 @@ import { AutomationDeliveryManager, AutomationManager, AutomationRouteStore } fr
 import { ChannelPluginRegistry, ChannelPolicyManager, RouteBindingManager, SurfaceRegistry } from '@pellux/goodvibes-sdk/platform/channels';
 import { ChannelDeliveryRouter } from '@pellux/goodvibes-sdk/platform/channels';
 import { ApprovalBroker, GatewayMethodCatalog, SharedSessionBroker } from '@pellux/goodvibes-sdk/platform/control-plane';
+import type { SharedSessionRoutingIntent } from '@pellux/goodvibes-sdk/platform/control-plane';
 import { WatcherRegistry } from '@pellux/goodvibes-sdk/platform/watchers';
 import { ArtifactStore } from '@pellux/goodvibes-sdk/platform/artifacts';
 import {
@@ -89,6 +90,7 @@ import {
   type WorkflowServices,
 } from '@pellux/goodvibes-sdk/platform/tools';
 import { WorkPlanStore } from '../work-plans/work-plan-store.ts';
+import { AgentExecutionLedger } from './execution-ledger.ts';
 
 type WorktreeRegistry = RuntimeShell.WorktreeRegistry;
 type SdkRuntimeServices = RuntimeFoundationClientsOptions['runtimeServices'];
@@ -130,6 +132,64 @@ function buildFallbackModelDefinition(provider: string, modelId: string): ModelD
   };
 }
 
+function normalizeSharedSessionModelId(modelId: string | undefined, providerId: string | undefined): string | undefined {
+  const trimmedModelId = modelId?.trim();
+  if (!trimmedModelId) return undefined;
+  const trimmedProviderId = providerId?.trim();
+  const separatorIndex = trimmedModelId.indexOf(':');
+  if (separatorIndex > 0) return trimmedModelId;
+  if (trimmedProviderId) return `${trimmedProviderId}:${trimmedModelId}`;
+  return trimmedModelId;
+}
+
+function normalizeSharedSessionFallbackModels(models: readonly string[] | undefined): string[] {
+  return (models ?? [])
+    .filter((model): model is string => typeof model === 'string' && model.trim().length > 0)
+    .map((model) => {
+      const trimmed = model.trim();
+      const separatorIndex = trimmed.indexOf(':');
+      if (separatorIndex <= 0 || separatorIndex === trimmed.length - 1) {
+        throw new Error(`Shared-session fallback model '${model}' must be provider-qualified.`);
+      }
+      return trimmed;
+    });
+}
+
+function buildAgentSpawnRoutingFromSharedSession(
+  routing: SharedSessionRoutingIntent | undefined,
+  options: { readonly restrictTools?: boolean | undefined } = {},
+): Partial<Parameters<AgentManager['spawn']>[0]> {
+  if (!routing) return options.restrictTools ? { restrictTools: true } : {};
+  const provider = routing.providerId?.trim();
+  const model = normalizeSharedSessionModelId(routing.modelId, provider);
+  if (provider && !model) {
+    throw new Error('Shared-session provider routing requires a provider-qualified model when provider is supplied.');
+  }
+  const fallbackModels = normalizeSharedSessionFallbackModels(routing.fallbackModels);
+  const providerFailurePolicy = routing.providerFailurePolicy ?? (
+    fallbackModels.length ? 'ordered-fallbacks' : 'fail'
+  );
+  if (providerFailurePolicy === 'ordered-fallbacks' && fallbackModels.length === 0) {
+    throw new Error('Shared-session ordered fallback routing requires at least one provider-qualified fallback model.');
+  }
+  if (providerFailurePolicy === 'fail' && fallbackModels.length > 0) {
+    throw new Error('Shared-session fail routing cannot include fallback models; use ordered-fallbacks to enable model failover.');
+  }
+  return {
+    ...(model ? { model } : {}),
+    ...(provider ? { provider } : {}),
+    ...(routing.tools?.length ? { tools: [...routing.tools] } : {}),
+    ...(options.restrictTools ? { restrictTools: true } : {}),
+    routing: {
+      providerSelection: routing.providerSelection ?? (provider ? 'concrete' : 'inherit-current'),
+      providerFailurePolicy,
+      ...(fallbackModels.length ? { fallbackModels } : {}),
+    },
+    ...(routing.executionIntent ? { executionIntent: routing.executionIntent } : {}),
+    ...(routing.reasoningEffort ? { reasoningEffort: routing.reasoningEffort } : {}),
+  };
+}
+
 class DisabledAgentWorktreeRegistry extends runtimeShell.WorktreeRegistry {
   public override async list(): Promise<Awaited<ReturnType<WorktreeRegistry['list']>>> {
     return [] as Awaited<ReturnType<WorktreeRegistry['list']>>;
@@ -405,6 +465,7 @@ export interface RuntimeServices extends SdkRuntimeServices {
   readonly processManager: ProcessManager;
   readonly modeManager: ModeManager;
   readonly fileUndoManager: FileUndoManager;
+  readonly executionLedger: AgentExecutionLedger;
   readonly integrationHelpers: IntegrationHelperService;
   /**
    * Re-root workspace-bound stores to a new working directory.
@@ -516,6 +577,7 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     surfaceRoot: GOODVIBES_AGENT_SURFACE_ROOT,
     createWorktree: createDisabledAgentWrfcWorktreeOps,
   }]) as WrfcController;
+  agentManager.setWrfcController(wrfcController);
   const hookDispatcher = new HookDispatcher({ toolLLM, projectRoot: workingDirectory }, hookActivityTracker);
   configManager.attachHookDispatcher(hookDispatcher);
   const hookWorkbench = createHookWorkbench({
@@ -532,11 +594,13 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     messageSender: agentMessageBus,
   });
   sessionBroker.setContinuationRunner(async ({ task, input }) => {
-    throw new Error([
-      'GoodVibes Agent does not own shared-session task execution.',
-      `Received task for session ${input.sessionId}: ${task}`,
-      'Delegate explicit build/fix/review work to GoodVibes TUI through the public shared-session/build-delegation contract.',
-    ].join(' '));
+    const record = agentManager.spawn({
+      mode: 'spawn',
+      task,
+      ...buildAgentSpawnRoutingFromSharedSession(input.routing, { restrictTools: true }),
+      context: `shared-session:${input.sessionId}`,
+    });
+    return { agentId: record.id };
   });
   const artifactStore = new ArtifactStore({ configManager });
   const memoryEmbeddingRegistry = new MemoryEmbeddingProviderRegistry({ configManager });
@@ -562,11 +626,23 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     runtimeBus: options.runtimeBus,
     deliveryManager,
     spawnTask: (input) => {
-      throw new Error([
-        'GoodVibes Agent does not create local automation jobs and does not spawn local automation agents.',
-        `Received automation prompt: ${input.prompt}`,
-        'Use read-only automation observability here; explicit build/fix/review execution belongs to GoodVibes TUI delegation.',
-      ].join(' '));
+      const record = agentManager.spawn({
+        mode: 'spawn',
+        task: input.prompt,
+        ...(input.modelId ? { model: input.modelId } : {}),
+        ...(input.modelProvider ? { provider: input.modelProvider } : {}),
+        ...(input.fallbackModels ? { fallbackModels: [...input.fallbackModels] } : {}),
+        ...(input.routing ? { routing: input.routing } : {}),
+        ...(input.executionIntent ? { executionIntent: input.executionIntent } : {}),
+        ...(input.template ? { template: input.template } : {}),
+        ...(input.reasoningEffort ? { reasoningEffort: input.reasoningEffort } : {}),
+        ...(input.toolAllowlist ? { tools: [...input.toolAllowlist], restrictTools: true } : {}),
+        context: [
+          'automation-manager:visible-agent',
+          input.context,
+        ].filter((part): part is string => Boolean(part?.trim())).join('\n\n'),
+      });
+      return record.id;
     },
   });
   const agentKnowledgeStore = new KnowledgeStore({
@@ -684,6 +760,7 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
   const processManager = new ProcessManager();
   const modeManager = new ModeManager();
   const fileUndoManager = new FileUndoManager();
+  const executionLedger = new AgentExecutionLedger(options.runtimeBus);
   const integrationHelpers = new IntegrationHelperService({
     workingDirectory,
     homeDirectory,
@@ -816,6 +893,7 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     processManager,
     modeManager,
     fileUndoManager,
+    executionLedger,
     integrationHelpers,
     async rerootStores(newWorkingDir: string): Promise<void> {
       await projectIndex.reroot(newWorkingDir);