@pellux/goodvibes-sdk 0.18.14 → 0.18.15

package/dist/_internal/platform/agents/orchestrator.js

@@ -0,0 +1,318 @@
+import { ToolRegistry } from '@pellux/goodvibes-sdk/platform/tools/registry';
+import { registerAllTools } from '../tools/index.js';
+import { registerChannelAgentTools } from '../tools/channel/agent-tools.js';
+import { AgentMessageBus } from './message-bus.js';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+import { FileStateCache } from '@pellux/goodvibes-sdk/platform/state/file-cache';
+import { ProjectIndex } from '@pellux/goodvibes-sdk/platform/state/project-index';
+import { emitAgentCancelled, emitAgentCompleted, emitAgentFailed, emitAgentProgress, emitAgentRunning, emitAgentStreamDelta, emitOrchestrationNodeCancelled, emitOrchestrationNodeCompleted, emitOrchestrationNodeFailed, emitOrchestrationNodeProgress, } from '../runtime/emitters/index.js';
+import { splitModelRegistryKey } from '../providers/registry-helpers.js';
+import { runAgentTask } from './orchestrator-runner.js';
+export { summarizeToolArgs } from '@pellux/goodvibes-sdk/platform/agents/orchestrator-utils';
+/**
+ * AgentOrchestrator — runs AgentRecord tasks in-process.
+ *
+ * Each agent gets its own scoped ToolRegistry containing only the tools
+ * listed in record.tools. The execution loop itself now lives in
+ * `orchestrator-runner.ts`; this class owns shared registry/state wiring.
+ */
+export class AgentOrchestrator {
+    fullRegistry = null;
+    fullRegistryChannelVersion = -2;
+    toolDeps = null;
+    featureFlagManager = null;
+    runtimeBus = null;
+    channelRegistry;
+    messageBus;
+    constructor(config = {
+        messageBus: new AgentMessageBus(),
+    }) {
+        this.channelRegistry = config.channelRegistry ?? null;
+        this.messageBus = config.messageBus;
+    }
+    setRuntimeBus(runtimeBus) {
+        this.runtimeBus = runtimeBus;
+    }
+    /** Set the FeatureFlagManager for context-window awareness gating. */
+    setFeatureFlagManager(manager) {
+        this.featureFlagManager = manager;
+    }
+    emitterContext(agentId) {
+        return {
+            sessionId: 'agent-orchestrator',
+            traceId: `agent-orchestrator:${agentId}`,
+            source: 'agent-orchestrator',
+        };
+    }
+    emitAgentProgress(recordId, progress) {
+        if (!this.runtimeBus)
+            return;
+        emitAgentProgress(this.runtimeBus, this.emitterContext(recordId), {
+            agentId: recordId,
+            progress,
+        });
+    }
+    emitOrchestrationProgress(record, progress) {
+        if (!this.runtimeBus || !record.orchestrationGraphId || !record.orchestrationNodeId)
+            return;
+        emitOrchestrationNodeProgress(this.runtimeBus, this.emitterContext(record.id), {
+            graphId: record.orchestrationGraphId,
+            nodeId: record.orchestrationNodeId,
+            message: progress,
+        });
+    }
+    emitAgentStarted(recordId) {
+        if (!this.runtimeBus)
+            return;
+        emitAgentRunning(this.runtimeBus, this.emitterContext(recordId), { agentId: recordId });
+    }
+    emitAgentCancelledEvent(recordId, reason) {
+        if (!this.runtimeBus)
+            return;
+        emitAgentCancelled(this.runtimeBus, this.emitterContext(recordId), {
+            agentId: recordId,
+            reason,
+        });
+    }
+    emitOrchestrationCancelled(record, reason) {
+        if (!this.runtimeBus || !record.orchestrationGraphId || !record.orchestrationNodeId)
+            return;
+        emitOrchestrationNodeCancelled(this.runtimeBus, this.emitterContext(record.id), {
+            graphId: record.orchestrationGraphId,
+            nodeId: record.orchestrationNodeId,
+            reason,
+        });
+    }
+    emitAgentFailedEvent(recordId, error, durationMs) {
+        if (!this.runtimeBus)
+            return;
+        emitAgentFailed(this.runtimeBus, this.emitterContext(recordId), {
+            agentId: recordId,
+            error,
+            durationMs,
+        });
+    }
+    emitOrchestrationFailed(record, error) {
+        if (!this.runtimeBus || !record.orchestrationGraphId || !record.orchestrationNodeId)
+            return;
+        emitOrchestrationNodeFailed(this.runtimeBus, this.emitterContext(record.id), {
+            graphId: record.orchestrationGraphId,
+            nodeId: record.orchestrationNodeId,
+            error,
+        });
+    }
+    emitAgentCompletedEvent(recordId, durationMs, output, toolCallsMade) {
+        if (!this.runtimeBus)
+            return;
+        emitAgentCompleted(this.runtimeBus, this.emitterContext(recordId), {
+            agentId: recordId,
+            durationMs,
+            output,
+            toolCallsMade,
+        });
+    }
+    emitOrchestrationCompleted(record, output) {
+        if (!this.runtimeBus || !record.orchestrationGraphId || !record.orchestrationNodeId)
+            return;
+        emitOrchestrationNodeCompleted(this.runtimeBus, this.emitterContext(record.id), {
+            graphId: record.orchestrationGraphId,
+            nodeId: record.orchestrationNodeId,
+            summary: output.length > 120 ? `${output.slice(0, 117)}...` : output,
+        });
+    }
+    emitStreamDelta(recordId, content, accumulated) {
+        if (!this.runtimeBus || !content)
+            return;
+        emitAgentStreamDelta(this.runtimeBus, this.emitterContext(recordId), {
+            agentId: recordId,
+            content,
+            accumulated,
+        });
+    }
+    /**
+     * Inject shared file-cache and project-index so agent tools share state with main session.
+     * Call once during application startup, before any agents are spawned.
+     */
+    setDependencies(toolDeps) {
+        this.toolDeps = toolDeps;
+        this.fullRegistry = null;
+        this.fullRegistryChannelVersion = -2;
+    }
+    /** Lazily build and cache the full ToolRegistry. */
+    getFullRegistry() {
+        const channelVersion = this.channelRegistry?.getVersion() ?? -1;
+        if (!this.fullRegistry || this.fullRegistryChannelVersion !== channelVersion) {
+            if (!this.toolDeps?.configManager || !this.toolDeps?.providerRegistry || !this.toolDeps?.toolLLM) {
+                throw new Error('AgentOrchestrator requires configManager, providerRegistry, and toolLLM dependencies before tool registration');
+            }
+            this.fullRegistry = new ToolRegistry();
+            registerAllTools(this.fullRegistry, this.toolDeps);
+            registerChannelAgentTools(this.fullRegistry, this.toolDeps?.channelRegistry ?? this.channelRegistry);
+            this.fullRegistryChannelVersion = channelVersion;
+        }
+        return this.fullRegistry;
+    }
+    /**
+     * Build a ToolRegistry containing only the tools whose names appear in
+     * the allowedNames list. Filters the provided full registry into a fresh
+     * scoped registry.
+     */
+    buildScopedRegistry(allowedNames, fullRegistry) {
+        const allowed = new Set(allowedNames.filter((n) => n !== 'agent'));
+        const scopedRegistry = new ToolRegistry();
+        for (const tool of fullRegistry.list()) {
+            if (allowed.has(tool.definition.name)) {
+                scopedRegistry.register(tool);
+            }
+        }
+        return scopedRegistry;
+    }
+    resolveProviderForRecord(providerRegistry, record, currentModel) {
+        const routing = this.resolveProviderRouting(record, currentModel);
+        const scopedModelId = this.normalizeRequestedModelId(routing.requestedModelId, routing.providerOverride);
+        try {
+            return {
+                provider: providerRegistry.getForModel(scopedModelId, routing.providerOverride),
+                modelId: this.resolveChatModelId(providerRegistry, scopedModelId, routing.providerOverride),
+                requestedModelId: scopedModelId,
+            };
+        }
+        catch (err) {
+            if (routing.requestedModelId !== currentModel.id && routing.unresolvedModelPolicy === 'fallback-to-current') {
+                logger.debug(`[AgentOrchestrator] Requested model '${routing.requestedModelId}' not found, falling back to '${currentModel.id}'`);
+                try {
+                    return {
+                        provider: providerRegistry.getForModel(currentModel.id, currentModel.provider),
+                        modelId: this.resolveChatModelId(providerRegistry, currentModel.id, currentModel.provider),
+                        requestedModelId: currentModel.id,
+                    };
+                }
+                catch (fallbackErr) {
+                    throw new Error(`Cannot resolve provider for model '${routing.requestedModelId}' (${summarizeError(err)}) or fallback '${currentModel.id}' (${summarizeError(fallbackErr)})`);
+                }
+            }
+            throw new Error(`Cannot resolve provider for model '${scopedModelId}': ${summarizeError(err)}`);
+        }
+    }
+    resolveProviderRouting(record, currentModel) {
+        const requestedModelId = record.model ?? currentModel.id;
+        const fallbackModels = (record.routing?.fallbackModels
+            ?? record.fallbackModels
+            ?? [])
+            .filter((model) => typeof model === 'string' && model.trim().length > 0)
+            .map((model) => model.trim());
+        const providerSelection = record.routing?.providerSelection ?? (record.provider === 'synthetic'
+            ? 'synthetic'
+            : record.provider
+                ? 'concrete'
+                : 'inherit-current');
+        const providerId = record.provider;
+        const effectiveProviderId = providerSelection === 'synthetic'
+            ? undefined
+            : providerSelection === 'concrete'
+                ? (providerId ?? currentModel.provider)
+                : currentModel.provider;
+        const providerOverride = effectiveProviderId !== 'synthetic'
+            ? effectiveProviderId
+            : undefined;
+        const unresolvedModelPolicy = record.routing?.unresolvedModelPolicy ?? (providerOverride && providerOverride !== currentModel.provider
+            ? 'fail'
+            : 'fallback-to-current');
+        return {
+            requestedModelId,
+            providerSelection,
+            unresolvedModelPolicy,
+            providerFailurePolicy: record.routing?.providerFailurePolicy ?? (fallbackModels.length > 0
+                ? 'ordered-fallbacks'
+                : 'fail'),
+            providerId,
+            providerOverride,
+            fallbackModels,
+        };
+    }
+    normalizeRequestedModelId(requestedModelId, providerOverride) {
+        if (!providerOverride || !requestedModelId.includes(':')) {
+            return requestedModelId;
+        }
+        return splitModelRegistryKey(requestedModelId).resolvedModelId;
+    }
+    resolveChatModelId(providerRegistry, requestedModelId, providerOverride) {
+        const registry = providerRegistry.listModels();
+        const def = requestedModelId.includes(':')
+            ? providerOverride
+                ? registry.find((model) => model.registryKey === requestedModelId && model.provider === providerOverride)
+                    ?? registry.find((model) => model.id === splitModelRegistryKey(requestedModelId).resolvedModelId && model.provider === providerOverride)
+                : registry.find((model) => model.registryKey === requestedModelId)
+                    ?? registry.find((model) => model.id === requestedModelId)
+                    ?? registry.find((model) => model.id === splitModelRegistryKey(requestedModelId).resolvedModelId)
+            : providerOverride
+                ? registry.find((model) => model.id === requestedModelId && model.provider === providerOverride)
+                : registry.find((model) => model.id === requestedModelId);
+        if (def)
+            return def.id;
+        return requestedModelId;
+    }
+    resolveFallbackModelRoutes(providerRegistry, record, currentModel, primaryRequestedModelId) {
+        const routing = this.resolveProviderRouting(record, currentModel);
+        if (routing.providerFailurePolicy !== 'ordered-fallbacks' || routing.fallbackModels.length === 0) {
+            return [];
+        }
+        const seen = new Set([primaryRequestedModelId]);
+        const routes = [];
+        for (const rawFallback of routing.fallbackModels) {
+            const requestedModelId = this.normalizeRequestedModelId(rawFallback, routing.providerOverride);
+            if (!requestedModelId || seen.has(requestedModelId))
+                continue;
+            seen.add(requestedModelId);
+            try {
+                routes.push({
+                    provider: providerRegistry.getForModel(requestedModelId, routing.providerOverride),
+                    modelId: this.resolveChatModelId(providerRegistry, requestedModelId, routing.providerOverride),
+                    requestedModelId,
+                });
+            }
+            catch (error) {
+                logger.warn('[AgentOrchestrator] Ignoring unresolved fallback model', {
+                    agentId: record.id,
+                    modelId: requestedModelId,
+                    error: summarizeError(error),
+                });
+            }
+        }
+        return routes;
+    }
+    createRunContext() {
+        return {
+            workingDirectory: this.toolDeps.workingDirectory,
+            runtimeBus: this.runtimeBus,
+            featureFlagManager: this.featureFlagManager,
+            emitterContext: (agentId) => this.emitterContext(agentId),
+            emitAgentProgress: (recordId, progress) => this.emitAgentProgress(recordId, progress),
+            emitOrchestrationProgress: (record, progress) => this.emitOrchestrationProgress(record, progress),
+            emitAgentStarted: (recordId) => this.emitAgentStarted(recordId),
+            emitAgentCancelledEvent: (recordId, reason) => this.emitAgentCancelledEvent(recordId, reason),
+            emitOrchestrationCancelled: (record, reason) => this.emitOrchestrationCancelled(record, reason),
+            emitAgentFailedEvent: (recordId, error, durationMs) => this.emitAgentFailedEvent(recordId, error, durationMs),
+            emitOrchestrationFailed: (record, error) => this.emitOrchestrationFailed(record, error),
+            emitAgentCompletedEvent: (recordId, durationMs, output, toolCallsMade) => this.emitAgentCompletedEvent(recordId, durationMs, output, toolCallsMade),
+            emitOrchestrationCompleted: (record, output) => this.emitOrchestrationCompleted(record, output),
+            emitStreamDelta: (recordId, content, accumulated) => this.emitStreamDelta(recordId, content, accumulated),
+            processManager: this.toolDeps?.processManager,
+            messageBus: this.messageBus,
+            knowledgeService: this.toolDeps?.knowledgeService,
+            memoryRegistry: this.toolDeps?.memoryRegistry,
+            archetypeLoader: this.toolDeps?.archetypeLoader,
+            providerOptimizer: this.toolDeps?.providerOptimizer,
+            providerRegistry: this.toolDeps.providerRegistry,
+            getFullRegistry: () => this.getFullRegistry(),
+            buildScopedRegistry: (allowedNames, fullRegistry) => this.buildScopedRegistry(allowedNames, fullRegistry),
+            resolveProviderForRecord: (providerRegistry, record, currentModel) => this.resolveProviderForRecord(providerRegistry, record, currentModel),
+            resolveFallbackModelRoutes: (providerRegistry, record, currentModel, primaryRequestedModelId) => this.resolveFallbackModelRoutes(providerRegistry, record, currentModel, primaryRequestedModelId),
+        };
+    }
+    /** Run an agent task described by the given record. */
+    async runAgent(record) {
+        await runAgentTask(this.createRunContext(), record);
+    }
+}

package/dist/_internal/platform/agents/session.d.ts

@@ -0,0 +1,37 @@
+import { ConversationManager } from '../core/conversation.js';
+import { KVState } from '@pellux/goodvibes-sdk/platform/state/kv-state';
+export interface AgentSessionPaths {
+    readonly sessionsDir: string;
+    readonly stateDir: string;
+}
+/**
+ * AgentSession — Isolated session context for a spawned agent.
+ *
+ * Each agent gets its own ConversationManager, KVState namespace,
+ * and JSONL message log file.
+ */
+export declare class AgentSession {
+    /** The agent's unique identifier. */
+    readonly agentId: string;
+    /** Guard to ensure session directory is only created once. */
+    private dirCreated;
+    /** Isolated conversation history for this agent. */
+    readonly conversation: ConversationManager;
+    /** KV state namespaced under agentId. */
+    readonly kvState: KVState;
+    /** Path to the agent's JSONL message log. */
+    readonly sessionFile: string;
+    constructor(agentId: string, model: string, provider: string, paths: AgentSessionPaths);
+    /**
+     * Append a message record to the agent's JSONL log.
+     * Each record is written as a single JSON line.
+     */
+    appendMessage(msg: Record<string, unknown>): void;
+    /**
+     * Clean up resources held by this session.
+     * Flushes and disposes the KV state.
+     */
+    dispose(): Promise<void>;
+    private _ensureSessionDir;
+}
+//# sourceMappingURL=session.d.ts.map

package/dist/_internal/platform/agents/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/agents/session.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EAAE,OAAO,EAAE,MAAM,+CAA+C,CAAC;AAIxE,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAYD;;;;;GAKG;AACH,qBAAa,YAAY;IACvB,qCAAqC;IACrC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAEzB,8DAA8D;IAC9D,OAAO,CAAC,UAAU,CAAS;IAE3B,oDAAoD;IACpD,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAAC;IAE3C,yCAAyC;IACzC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAE1B,6CAA6C;IAC7C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;gBAEjB,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,iBAAiB;IA2BtF;;;OAGG;IACH,aAAa,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAWjD;;;OAGG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAa9B,OAAO,CAAC,iBAAiB;CAI1B"}

package/dist/_internal/platform/agents/session.js

@@ -0,0 +1,89 @@
+import { appendFileSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { ConversationManager } from '../core/conversation.js';
+import { KVState } from '@pellux/goodvibes-sdk/platform/state/kv-state';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+function resolveAgentSessionPaths(paths) {
+    if (!paths.sessionsDir || paths.sessionsDir.trim().length === 0) {
+        throw new Error('AgentSession requires a non-empty sessionsDir');
+    }
+    if (!paths.stateDir || paths.stateDir.trim().length === 0) {
+        throw new Error('AgentSession requires a non-empty stateDir');
+    }
+    return paths;
+}
+/**
+ * AgentSession — Isolated session context for a spawned agent.
+ *
+ * Each agent gets its own ConversationManager, KVState namespace,
+ * and JSONL message log file.
+ */
+export class AgentSession {
+    /** The agent's unique identifier. */
+    agentId;
+    /** Guard to ensure session directory is only created once. */
+    dirCreated = false;
+    /** Isolated conversation history for this agent. */
+    conversation;
+    /** KV state namespaced under agentId. */
+    kvState;
+    /** Path to the agent's JSONL message log. */
+    sessionFile;
+    constructor(agentId, model, provider, paths) {
+        this.agentId = agentId;
+        const resolvedPaths = resolveAgentSessionPaths(paths);
+        // Own ConversationManager — not shared with main session
+        this.conversation = new ConversationManager();
+        // KV state namespaced to this agent
+        this.kvState = new KVState({ sessionId: agentId, stateDir: resolvedPaths.stateDir });
+        // JSONL log path
+        this.sessionFile = join(resolvedPaths.sessionsDir, `${agentId}.jsonl`);
+        // Write a session-start entry
+        this._ensureSessionDir();
+        this.appendMessage({
+            type: 'meta',
+            agentId,
+            model,
+            provider,
+            title: '',
+            timestamp: Date.now(),
+        });
+        logger.debug('AgentSession created', { agentId, model, provider });
+    }
+    /**
+     * Append a message record to the agent's JSONL log.
+     * Each record is written as a single JSON line.
+     */
+    appendMessage(msg) {
+        try {
+            if (!this.dirCreated) {
+                this._ensureSessionDir();
+            }
+            appendFileSync(this.sessionFile, JSON.stringify(msg) + '\n', 'utf-8');
+        }
+        catch (err) {
+            logger.error('AgentSession.appendMessage failed', { agentId: this.agentId, error: summarizeError(err) });
+        }
+    }
+    /**
+     * Clean up resources held by this session.
+     * Flushes and disposes the KV state.
+     */
+    async dispose() {
+        try {
+            await this.kvState.dispose();
+        }
+        catch (err) {
+            logger.error('AgentSession.dispose failed', { agentId: this.agentId, error: summarizeError(err) });
+        }
+        logger.debug('AgentSession disposed', { agentId: this.agentId });
+    }
+    // ---------------------------------------------------------------------------
+    // Private helpers
+    // ---------------------------------------------------------------------------
+    _ensureSessionDir() {
+        mkdirSync(dirname(this.sessionFile), { recursive: true });
+        this.dirCreated = true;
+    }
+}

package/dist/_internal/platform/agents/worktree.d.ts

@@ -0,0 +1,45 @@
+/**
+ * AgentWorktree — Manages git worktree lifecycle for spawned agents.
+ *
+ * Each agent works in an isolated git worktree so its file changes are
+ * sandboxed from the main working tree.
+ *
+ * Lifecycle:
+ *   create()  — create worktree + branch, return path
+ *   merge()   — merge agent branch back to current branch, remove worktree
+ *   cleanup() — remove worktree without merging (cancel/error path)
+ */
+export declare class AgentWorktree {
+    private readonly git;
+    constructor(cwd: string);
+    /**
+     * Create a new worktree for the given agent.
+     * Returns the absolute path to the worktree directory.
+     */
+    create(agentId: string): Promise<string>;
+    /**
+     * Merge the agent's branch back into the current branch and remove the worktree.
+     * Returns true if a merge was performed, false if no changes were found.
+     */
+    merge(agentId: string): Promise<boolean>;
+    /**
+     * Remove the worktree without merging (cancel/error path).
+     */
+    cleanup(agentId: string): Promise<void>;
+    private _worktreePath;
+    private _branchName;
+    /**
+     * Check whether the agent branch has any commits that differ from
+     * the current branch (the main working tree HEAD).
+     */
+    private _hasChanges;
+    /**
+     * Force-remove a worktree directory.
+     */
+    private _removeWorktree;
+    /**
+     * Delete a branch (no-op if it doesn't exist).
+     */
+    private _deleteBranch;
+}
+//# sourceMappingURL=worktree.d.ts.map

package/dist/_internal/platform/agents/worktree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worktree.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/agents/worktree.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;GAUG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAa;gBAErB,GAAG,EAAE,MAAM;IAIvB;;;OAGG;IACG,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAU9C;;;OAGG;IACG,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IA4B9C;;OAEG;IACG,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAmB7C,OAAO,CAAC,aAAa;IAIrB,OAAO,CAAC,WAAW;IAInB;;;OAGG;YACW,WAAW;IAezB;;OAEG;YACW,eAAe;IAgB7B;;OAEG;YACW,aAAa;CAS5B"}

package/dist/_internal/platform/agents/worktree.js

@@ -0,0 +1,134 @@
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { simpleGit } from 'simple-git';
+import { GitService } from '../git/service.js';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+/**
+ * AgentWorktree — Manages git worktree lifecycle for spawned agents.
+ *
+ * Each agent works in an isolated git worktree so its file changes are
+ * sandboxed from the main working tree.
+ *
+ * Lifecycle:
+ *   create()  — create worktree + branch, return path
+ *   merge()   — merge agent branch back to current branch, remove worktree
+ *   cleanup() — remove worktree without merging (cancel/error path)
+ */
+export class AgentWorktree {
+    git;
+    constructor(cwd) {
+        this.git = new GitService(cwd);
+    }
+    /**
+     * Create a new worktree for the given agent.
+     * Returns the absolute path to the worktree directory.
+     */
+    async create(agentId) {
+        const worktreePath = this._worktreePath(agentId);
+        const branch = this._branchName(agentId);
+        logger.debug('AgentWorktree.create', { agentId, worktreePath, branch });
+        await this.git.worktreeAdd(worktreePath, branch);
+        return worktreePath;
+    }
+    /**
+     * Merge the agent's branch back into the current branch and remove the worktree.
+     * Returns true if a merge was performed, false if no changes were found.
+     */
+    async merge(agentId) {
+        const worktreePath = this._worktreePath(agentId);
+        const branch = this._branchName(agentId);
+        logger.debug('AgentWorktree.merge', { agentId, worktreePath, branch });
+        // Check if the agent branch has any commits beyond base
+        const hasChanges = await this._hasChanges(worktreePath, branch);
+        if (!hasChanges) {
+            logger.debug('AgentWorktree.merge: no changes, skipping merge', { agentId });
+            await this._removeWorktree(worktreePath);
+            await this._deleteBranch(branch);
+            return false;
+        }
+        // Remove worktree first (required before merging the branch)
+        await this._removeWorktree(worktreePath);
+        // Merge the branch
+        await this.git.merge(branch);
+        // Clean up the agent branch
+        await this._deleteBranch(branch);
+        logger.debug('AgentWorktree.merge: complete', { agentId });
+        return true;
+    }
+    /**
+     * Remove the worktree without merging (cancel/error path).
+     */
+    async cleanup(agentId) {
+        const worktreePath = this._worktreePath(agentId);
+        const branch = this._branchName(agentId);
+        logger.debug('AgentWorktree.cleanup', { agentId, worktreePath });
+        if (existsSync(worktreePath)) {
+            await this._removeWorktree(worktreePath);
+        }
+        await this._deleteBranch(branch).catch(() => {
+            // Branch may not exist if create() never completed
+        });
+    }
+    // ---------------------------------------------------------------------------
+    // Private helpers
+    // ---------------------------------------------------------------------------
+    _worktreePath(agentId) {
+        return join(this.git.getCwd(), '.goodvibes', '.worktrees', `agent-${agentId}`);
+    }
+    _branchName(agentId) {
+        return `agent/${agentId}`;
+    }
+    /**
+     * Check whether the agent branch has any commits that differ from
+     * the current branch (the main working tree HEAD).
+     */
+    async _hasChanges(worktreePath, branch) {
+        try {
+            // Use a simple-git instance pointed at the worktree to check status
+            const wgit = simpleGit({ baseDir: this.git.getCwd() });
+            // Count commits on the branch that aren't on the current branch
+            const result = await wgit.raw(['rev-list', '--count', `HEAD..${branch}`]);
+            const count = parseInt(result.trim(), 10);
+            return count > 0;
+        }
+        catch (err) {
+            // If rev-list fails (e.g. brand-new worktree with no commits), treat as no changes
+            logger.debug('AgentWorktree._hasChanges: rev-list failed, treating as no changes', { branch, error: summarizeError(err) });
+            return false;
+        }
+    }
+    /**
+     * Force-remove a worktree directory.
+     */
+    async _removeWorktree(worktreePath) {
+        try {
+            await this.git.worktreeRemove(worktreePath);
+        }
+        catch (err) {
+            // Try with --force flag via raw if normal remove fails
+            logger.debug('AgentWorktree._removeWorktree: first attempt failed, retrying with --force', { worktreePath, error: summarizeError(err) });
+            try {
+                const wgit = simpleGit({ baseDir: this.git.getCwd() });
+                await wgit.raw(['worktree', 'remove', '--force', worktreePath]);
+            }
+            catch (err) {
+                logger.error('AgentWorktree._removeWorktree failed', { worktreePath, error: summarizeError(err) });
+                throw err;
+            }
+        }
+    }
+    /**
+     * Delete a branch (no-op if it doesn't exist).
+     */
+    async _deleteBranch(branch) {
+        try {
+            const wgit = simpleGit({ baseDir: this.git.getCwd() });
+            await wgit.raw(['branch', '-D', branch]);
+        }
+        catch (err) {
+            // Branch may not exist — that's fine
+            logger.debug('AgentWorktree._deleteBranch: ignored error', { branch, error: summarizeError(err) });
+        }
+    }
+}

package/dist/_internal/platform/agents/wrfc-config.d.ts

@@ -0,0 +1,20 @@
+import type { ConfigManager } from '../config/manager.js';
+import type { AgentManager } from '../tools/agent/index.js';
+export type AgentManagerLike = Pick<AgentManager, 'spawn' | 'getStatus' | 'list' | 'cancel' | 'listByCohort' | 'clear'>;
+export type WrfcConfigLike = {
+    scoreThreshold: number;
+    maxFixAttempts: number;
+    autoCommit: boolean;
+    gates: Array<{
+        name: string;
+        command: string;
+        enabled: boolean;
+    }>;
+};
+export type WrfcConfigReader = Pick<ConfigManager, 'get' | 'getCategory'>;
+export declare function readWrfcConfig(configManager: WrfcConfigReader): WrfcConfigLike;
+export declare function getWrfcScoreThreshold(configManager: WrfcConfigReader): number;
+export declare function getWrfcMaxFixAttempts(configManager: WrfcConfigReader): number;
+export declare function getWrfcAutoCommit(configManager: WrfcConfigReader): boolean;
+export declare function getEnabledWrfcGates(configManager: WrfcConfigReader): WrfcConfigLike['gates'];
+//# sourceMappingURL=wrfc-config.d.ts.map

package/dist/_internal/platform/agents/wrfc-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrfc-config.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/agents/wrfc-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAE5D,MAAM,MAAM,gBAAgB,GAAG,IAAI,CAAC,YAAY,EAAE,OAAO,GAAG,WAAW,GAAG,MAAM,GAAG,QAAQ,GAAG,cAAc,GAAG,OAAO,CAAC,CAAC;AACxH,MAAM,MAAM,cAAc,GAAG;IAC3B,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,OAAO,CAAC;IACpB,KAAK,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;CACnE,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,IAAI,CAAC,aAAa,EAAE,KAAK,GAAG,aAAa,CAAC,CAAC;AAE1E,wBAAgB,cAAc,CAAC,aAAa,EAAE,gBAAgB,GAAG,cAAc,CAiB9E;AAED,wBAAgB,qBAAqB,CAAC,aAAa,EAAE,gBAAgB,GAAG,MAAM,CAE7E;AAED,wBAAgB,qBAAqB,CAAC,aAAa,EAAE,gBAAgB,GAAG,MAAM,CAE7E;AAED,wBAAgB,iBAAiB,CAAC,aAAa,EAAE,gBAAgB,GAAG,OAAO,CAE1E;AAED,wBAAgB,mBAAmB,CAAC,aAAa,EAAE,gBAAgB,GAAG,cAAc,CAAC,OAAO,CAAC,CAE5F"}