@amaster.ai/pi-teamwork 0.1.2-beta.9 → 0.1.3

package/dist/index.js

@@ -1,35 +1,165 @@
-import { loadPiSettings, resolveAgentDir } from '@amaster.ai/pi-shared/settings';
+import { spawn } from 'node:child_process';
+import { loadPiSettings } from '@amaster.ai/pi-shared/settings';
+import { defineTool } from '@earendil-works/pi-coding-agent';
 import { Type } from 'typebox';
+import { initAmasterProvider } from './adapters/amaster.js';
 import { initMulticaProvider } from './adapters/multica.js';
 const SETTINGS_KEY = 'pi-teamwork';
 const STATUS_KEY = 'pi-teamwork';
+const TEAMWORK_TOOL_ORDER = [
+    'workspace_list',
+    'issue_list',
+    'issue_get',
+    'issue_create',
+    'issue_update',
+    'issue_comment',
+    'project_list',
+    'user_directory_list',
+    'teamwork_status',
+];
+const TEAMWORK_TOOL_NAMES = new Set(TEAMWORK_TOOL_ORDER);
+const TEAMWORK_GUIDANCE = [
+    '<teamwork-guidance>',
+    'You are working in a shared project tracker (teamwork) where humans and other agents collaborate. Use the issue_* and project_* tools to keep that shared space in sync.',
+    '',
+    'Before starting non-trivial work, check whether a relevant issue already exists (issue_list / issue_get) — to avoid duplicating work another collaborator has picked up.',
+    '',
+    'When you reach meaningful progress, hit a blocker, or need input from a collaborator, leave a comment on the relevant issue (issue_comment). Comments are how humans and other agents observe what you are doing.',
+    '',
+    'When you finish work that an issue describes, update its status (issue_update). An issue left in an outdated state misleads other collaborators.',
+    '',
+    'The tracker is for cross-collaborator coordination, not for tracking your own session-local TODOs. Do not file an issue just to remind yourself of something within the current conversation.',
+    '</teamwork-guidance>',
+].join('\n');
 export default function piTeamworkExtension(pi) {
     let provider;
-    const exec = async (command, args) => {
-        const result = await pi.exec(command, args);
-        return { stdout: result.stdout, stderr: result.stderr, code: result.code };
-    };
+    let readyPromise;
+    let sessionGeneration = 0;
+    const registeredToolNames = new Set();
+    const suspendedToolNames = new Set();
+    async function ensureReady() {
+        if (readyPromise)
+            await readyPromise;
+        if (!provider)
+            return 'Teamwork provider is not initialized.';
+        return undefined;
+    }
+    function getProvider() {
+        if (!provider)
+            throw new Error('Teamwork provider is not initialized.');
+        return provider;
+    }
+    const teamworkTools = createTeamworkTools(ensureReady, getProvider);
+    function registerProviderTools(adapter) {
+        const supportedToolNames = supportedToolNamesForProvider(adapter);
+        for (const tool of teamworkTools) {
+            if (!supportedToolNames.has(tool.name) || registeredToolNames.has(tool.name)) {
+                continue;
+            }
+            pi.registerTool(tool);
+            registeredToolNames.add(tool.name);
+        }
+        alignActiveTeamworkTools(pi, supportedToolNames, suspendedToolNames);
+    }
+    function suspendTeamworkTools() {
+        alignActiveTeamworkTools(pi, new Set(), suspendedToolNames);
+    }
     pi.on('session_start', async (_event, ctx) => {
+        const generation = ++sessionGeneration;
+        provider = undefined;
+        readyPromise = undefined;
         const config = loadConfig(ctx.cwd);
         if (config.enabled === false) {
+            suspendTeamworkTools();
             ctx.ui.setStatus(STATUS_KEY, 'teamwork: disabled');
             return;
         }
+        const exec = async (command, args) => {
+            const result = await pi.exec(command, args, { cwd: ctx.cwd });
+            return { stdout: result.stdout, stderr: result.stderr, code: result.code };
+        };
         const providerName = config.provider ?? 'multica';
-        if (providerName === 'multica') {
-            provider = await initMulticaProvider(config.multica ?? {}, exec);
-            ctx.ui.setStatus(STATUS_KEY, 'teamwork: multica');
+        if (providerName === 'amaster') {
+            const amasterConfig = { ...(config.amaster ?? {}) };
+            const eventRecord = _event && typeof _event === 'object' && !Array.isArray(_event)
+                ? _event
+                : undefined;
+            const amasterEmployee = eventRecord?.amasterEmployee;
+            const sessionApiKey = amasterEmployee && typeof amasterEmployee === 'object' && !Array.isArray(amasterEmployee)
+                ? amasterEmployee.apiKey
+                : undefined;
+            const apiKey = typeof sessionApiKey === 'string' && sessionApiKey.trim()
+                ? sessionApiKey.trim()
+                : typeof amasterConfig.apiKey === 'string' && amasterConfig.apiKey.trim()
+                    ? amasterConfig.apiKey.trim()
+                    : undefined;
+            delete amasterConfig.apiKey;
+            const amasterExec = apiKey
+                ? (command, args) => command === 'amaster-employee'
+                    ? execWithEnv(command, args, { AMASTER_BOARD_API_KEY: apiKey }, ctx.cwd)
+                    : exec(command, args)
+                : exec;
+            const adapter = await initAmasterProvider(amasterConfig, amasterExec);
+            if (generation !== sessionGeneration)
+                return;
+            provider = adapter;
+            registerProviderTools(adapter);
+            ctx.ui.setStatus(STATUS_KEY, 'teamwork: amaster');
+            return;
         }
-        else {
+        if (providerName !== 'multica') {
+            suspendTeamworkTools();
             ctx.ui.setStatus(STATUS_KEY, `teamwork: unknown provider "${providerName}"`);
+            return;
         }
+        readyPromise = (async () => {
+            const { adapter, installResult } = await initMulticaProvider(config.multica ?? {}, exec);
+            if (generation !== sessionGeneration)
+                return;
+            provider = adapter;
+            registerProviderTools(adapter);
+            if (!installResult.installed) {
+                ctx.ui.notify(`multica CLI could not be installed: ${installResult.error ?? 'unknown error'}. Run "multica setup" manually.`, 'warning');
+                ctx.ui.setStatus(STATUS_KEY, 'teamwork: multica (not installed)');
+                return;
+            }
+            if (!installResult.alreadyPresent) {
+                ctx.ui.notify('multica CLI was auto-installed successfully.', 'info');
+            }
+            if (!config.multica?.token && !config.multica?.serverUrl) {
+                ctx.ui.notify('No multica token or serverUrl configured. Run "multica setup" to authenticate.', 'warning');
+            }
+            if (config.multica?.serverUrl && !config.multica?.appUrl) {
+                ctx.ui.notify('multica serverUrl is set but appUrl is missing. Remote servers require both.', 'warning');
+            }
+            ctx.ui.setStatus(STATUS_KEY, 'teamwork: multica');
+        })().catch((err) => {
+            if (generation !== sessionGeneration)
+                return;
+            ctx.ui.setStatus(STATUS_KEY, `teamwork: multica (error: ${err instanceof Error ? err.message : String(err)})`);
+        });
     });
     pi.on('session_shutdown', async () => {
+        sessionGeneration++;
         provider = undefined;
+        readyPromise = undefined;
+    });
+    pi.on('before_agent_start', async (event) => {
+        if (readyPromise)
+            await readyPromise;
+        if (!provider)
+            return;
+        return {
+            systemPrompt: event.systemPrompt
+                ? `${event.systemPrompt}\n\n${TEAMWORK_GUIDANCE}`
+                : TEAMWORK_GUIDANCE,
+        };
     });
     pi.registerCommand('teamwork-status', {
         description: 'Show teamwork provider status.',
         handler: async (_args, ctx) => {
+            if (readyPromise)
+                await readyPromise;
             if (!provider) {
                 ctx.ui.notify('Teamwork provider is not initialized.', 'warning');
                 return;
@@ -43,172 +173,319 @@ export default function piTeamworkExtension(pi) {
             }
         },
     });
-    // --- LLM-callable tools ---
-    pi.registerTool({
-        name: 'issue_list',
-        label: 'Teamwork',
-        description: 'List issues from the project management system. Supports filtering by status, assignee, and project.',
-        promptSnippet: 'List issues from the team project tracker with optional filters.',
-        parameters: Type.Object({
-            status: Type.Optional(Type.String({ description: 'Filter by status (e.g. todo, in_progress, done, blocked).' })),
-            assignee: Type.Optional(Type.String({ description: 'Filter by assignee name.' })),
-            project: Type.Optional(Type.String({ description: 'Filter by project ID.' })),
-            limit: Type.Optional(Type.Number({ description: 'Max number of results.' })),
+}
+function createTeamworkTools(ensureReady, getProvider) {
+    return [
+        defineTool({
+            name: 'workspace_list',
+            label: 'Teamwork',
+            description: 'List all workspaces you belong to. Use this to discover or switch workspaces. For the AMaster provider, workspaceId is the canonical AMaster companyId passed to the CLI as -C.',
+            promptSnippet: 'List workspaces in the shared project tracker.',
+            parameters: Type.Object({}),
+            async execute() {
+                const err = await ensureReady();
+                if (err)
+                    return textResult(err);
+                try {
+                    const workspaces = await getProvider().listWorkspaces();
+                    if (workspaces.length === 0)
+                        return textResult('No workspaces found.');
+                    return textResult(JSON.stringify(workspaces, null, 2));
+                }
+                catch (error) {
+                    return textResult(`Error: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            },
         }),
-        async execute(_toolCallId, params) {
-            if (!provider)
-                return textResult('Teamwork provider is not initialized.');
-            try {
-                const issues = await provider.listIssues(params);
-                if (issues.length === 0)
-                    return textResult('No issues found.');
-                return textResult(JSON.stringify(issues, null, 2));
-            }
-            catch (error) {
-                return textResult(`Error: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        },
-    });
-    pi.registerTool({
-        name: 'issue_get',
-        label: 'Teamwork',
-        description: 'Get detailed information about a specific issue.',
-        parameters: Type.Object({
-            id: Type.String({ description: 'The issue ID.' }),
+        defineTool({
+            name: 'issue_list',
+            label: 'Teamwork',
+            description: 'List issues from a shared project tracker. Issues are work items that humans or other agents collaborate on. Supports filtering by status, assignee, and project.',
+            promptSnippet: 'List issues from a shared project tracker where humans and agents collaborate.',
+            parameters: Type.Object({
+                workspaceId: Type.Optional(Type.String({
+                    description: 'Workspace ID. For AMaster provider this is the canonical companyId from workspace_list and is passed to the CLI as -C. Optional when the account has exactly one workspace.',
+                })),
+                status: Type.Optional(Type.String({ description: 'Filter by status (e.g. todo, in_progress, done, blocked).' })),
+                assignee: Type.Optional(Type.String({ description: 'Filter by assignee name.' })),
+                project: Type.Optional(Type.String({ description: 'Filter by project ID.' })),
+                limit: Type.Optional(Type.Number({ description: 'Max number of results.' })),
+            }),
+            async execute(_toolCallId, params) {
+                const err = await ensureReady();
+                if (err)
+                    return textResult(err);
+                try {
+                    const issues = await getProvider().listIssues(params);
+                    if (issues.length === 0)
+                        return textResult('No issues found.');
+                    return textResult(JSON.stringify(issues, null, 2));
+                }
+                catch (error) {
+                    return textResult(`Error: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            },
         }),
-        async execute(_toolCallId, params) {
-            if (!provider)
-                return textResult('Teamwork provider is not initialized.');
-            try {
-                const issue = await provider.getIssue(params.id);
-                if (!issue)
-                    return textResult(`Issue not found: ${params.id}`);
-                return textResult(JSON.stringify(issue, null, 2));
-            }
-            catch (error) {
-                return textResult(`Error: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        },
-    });
-    pi.registerTool({
-        name: 'issue_create',
-        label: 'Teamwork',
-        description: 'Create a new issue in the project management system.',
-        promptSnippet: 'Create issues in the team project tracker.',
-        parameters: Type.Object({
-            title: Type.String({ description: 'Issue title.' }),
-            description: Type.Optional(Type.String({ description: 'Issue description.' })),
-            priority: Type.Optional(Type.String({ description: 'Priority (e.g. low, medium, high, urgent).' })),
-            assignee: Type.Optional(Type.String({ description: 'Assignee name.' })),
-            project: Type.Optional(Type.String({ description: 'Project ID to associate with.' })),
+        defineTool({
+            name: 'issue_get',
+            label: 'Teamwork',
+            description: 'Get detailed information about a specific issue (a work item in the shared project tracker).',
+            parameters: Type.Object({
+                workspaceId: Type.Optional(Type.String({
+                    description: 'Workspace ID. For AMaster provider this is the canonical companyId from workspace_list and is passed to the CLI as -C. Optional when the account has exactly one workspace.',
+                })),
+                id: Type.String({ description: 'The issue ID.' }),
+            }),
+            async execute(_toolCallId, params) {
+                const err = await ensureReady();
+                if (err)
+                    return textResult(err);
+                try {
+                    const issue = await getProvider().getIssue(params.id, params.workspaceId);
+                    if (!issue)
+                        return textResult(`Issue not found: ${params.id}`);
+                    return textResult(JSON.stringify(issue, null, 2));
+                }
+                catch (error) {
+                    return textResult(`Error: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            },
         }),
-        async execute(_toolCallId, params) {
-            if (!provider)
-                return textResult('Teamwork provider is not initialized.');
-            try {
-                const issue = await provider.createIssue(params);
-                return textResult(JSON.stringify(issue, null, 2));
-            }
-            catch (error) {
-                return textResult(`Error: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        },
-    });
-    pi.registerTool({
-        name: 'issue_update',
-        label: 'Teamwork',
-        description: 'Update an existing issue. Can change title, description, status, priority, or assignee.',
-        parameters: Type.Object({
-            id: Type.String({ description: 'The issue ID to update.' }),
-            title: Type.Optional(Type.String({ description: 'New title.' })),
-            description: Type.Optional(Type.String({ description: 'New description.' })),
-            status: Type.Optional(Type.String({
-                description: 'New status (e.g. todo, in_progress, in_review, done, blocked, cancelled).',
-            })),
-            priority: Type.Optional(Type.String({ description: 'New priority.' })),
-            assignee: Type.Optional(Type.String({ description: 'New assignee name.' })),
+        defineTool({
+            name: 'issue_create',
+            label: 'Teamwork',
+            description: 'Create a new issue (a work item / ticket) in the shared project tracker. Use this to file work for humans or other agents to pick up.',
+            promptSnippet: 'Create issues / tickets in a shared project tracker for humans or agents to collaborate on.',
+            parameters: Type.Object({
+                workspaceId: Type.Optional(Type.String({
+                    description: 'Workspace ID. For AMaster provider this is the canonical companyId from workspace_list and is passed to the CLI as -C. Optional when the account has exactly one workspace.',
+                })),
+                title: Type.String({ description: 'Issue title.' }),
+                description: Type.Optional(Type.String({ description: 'Issue description.' })),
+                priority: Type.Optional(Type.String({ description: 'Priority (e.g. low, medium, high, urgent).' })),
+                assignee: Type.Optional(Type.String({ description: 'Assignee name.' })),
+                project: Type.Optional(Type.String({ description: 'Project ID to associate with.' })),
+            }),
+            async execute(_toolCallId, params) {
+                const err = await ensureReady();
+                if (err)
+                    return textResult(err);
+                try {
+                    const issue = await getProvider().createIssue(params);
+                    return textResult(JSON.stringify(issue, null, 2));
+                }
+                catch (error) {
+                    return textResult(`Error: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            },
         }),
-        async execute(_toolCallId, params) {
-            if (!provider)
-                return textResult('Teamwork provider is not initialized.');
-            const { id, ...input } = params;
-            try {
-                const issue = await provider.updateIssue(id, input);
-                if (!issue)
-                    return textResult(`Issue not found: ${id}`);
-                return textResult(JSON.stringify(issue, null, 2));
-            }
-            catch (error) {
-                return textResult(`Error: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        },
-    });
-    pi.registerTool({
-        name: 'issue_comment',
-        label: 'Teamwork',
-        description: 'Add a comment to an issue. Use for progress updates, questions, or blockers.',
-        parameters: Type.Object({
-            issueId: Type.String({ description: 'The issue ID to comment on.' }),
-            content: Type.String({ description: 'Comment content.' }),
-            parentId: Type.Optional(Type.String({ description: 'Parent comment ID for threaded replies.' })),
+        defineTool({
+            name: 'issue_update',
+            label: 'Teamwork',
+            description: 'Update an existing issue in the shared project tracker. Can change title, description, status, priority, or assignee.',
+            parameters: Type.Object({
+                workspaceId: Type.Optional(Type.String({
+                    description: 'Workspace ID. For AMaster provider this is the canonical companyId from workspace_list and is passed to the CLI as -C. Optional when the account has exactly one workspace.',
+                })),
+                id: Type.String({ description: 'The issue ID to update.' }),
+                title: Type.Optional(Type.String({ description: 'New title.' })),
+                description: Type.Optional(Type.String({ description: 'New description.' })),
+                status: Type.Optional(Type.String({
+                    description: 'New status (e.g. todo, in_progress, in_review, done, blocked, cancelled).',
+                })),
+                priority: Type.Optional(Type.String({ description: 'New priority.' })),
+                assignee: Type.Optional(Type.String({ description: 'New assignee name.' })),
+            }),
+            async execute(_toolCallId, params) {
+                const err = await ensureReady();
+                if (err)
+                    return textResult(err);
+                const { id, workspaceId, ...input } = params;
+                try {
+                    const issue = await getProvider().updateIssue(id, input, workspaceId);
+                    if (!issue)
+                        return textResult(`Issue not found: ${id}`);
+                    return textResult(JSON.stringify(issue, null, 2));
+                }
+                catch (error) {
+                    return textResult(`Error: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            },
         }),
-        async execute(_toolCallId, params) {
-            if (!provider)
-                return textResult('Teamwork provider is not initialized.');
-            try {
-                const comment = await provider.addComment(params.issueId, params.content, params.parentId);
-                return textResult(JSON.stringify(comment, null, 2));
-            }
-            catch (error) {
-                return textResult(`Error: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        },
-    });
-    pi.registerTool({
-        name: 'project_list',
-        label: 'Teamwork',
-        description: 'List all projects in the workspace.',
-        parameters: Type.Object({}),
-        async execute() {
-            if (!provider)
-                return textResult('Teamwork provider is not initialized.');
-            try {
-                const projects = await provider.listProjects();
-                if (projects.length === 0)
-                    return textResult('No projects found.');
-                return textResult(JSON.stringify(projects, null, 2));
-            }
-            catch (error) {
-                return textResult(`Error: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        },
-    });
-    pi.registerTool({
-        name: 'teamwork_status',
-        label: 'Teamwork',
-        description: 'Check the status of the teamwork provider (daemon status, connected agents, etc.).',
-        parameters: Type.Object({}),
-        async execute() {
-            if (!provider)
-                return textResult('Teamwork provider is not initialized.');
-            try {
-                const s = await provider.status();
-                return textResult(JSON.stringify(s, null, 2));
+        defineTool({
+            name: 'issue_comment',
+            label: 'Teamwork',
+            description: 'Add a comment to an issue in the shared project tracker. Use for progress updates, questions, or blockers visible to other collaborators (humans or agents).',
+            parameters: Type.Object({
+                workspaceId: Type.Optional(Type.String({
+                    description: 'Workspace ID. For AMaster provider this is the canonical companyId from workspace_list and is passed to the CLI as -C. Optional when the account has exactly one workspace.',
+                })),
+                issueId: Type.String({ description: 'The issue ID to comment on.' }),
+                content: Type.String({ description: 'Comment content.' }),
+                parentId: Type.Optional(Type.String({
+                    description: 'Optional provider-specific parent comment ID. The AMaster provider currently creates top-level comments.',
+                })),
+            }),
+            async execute(_toolCallId, params) {
+                const err = await ensureReady();
+                if (err)
+                    return textResult(err);
+                try {
+                    const comment = await getProvider().addComment(params.issueId, params.content, params.parentId, params.workspaceId);
+                    return textResult(JSON.stringify(comment, null, 2));
+                }
+                catch (error) {
+                    return textResult(`Error: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            },
+        }),
+        defineTool({
+            name: 'project_list',
+            label: 'Teamwork',
+            description: 'List all projects in a workspace.',
+            parameters: Type.Object({
+                workspaceId: Type.Optional(Type.String({
+                    description: 'Workspace ID. For AMaster provider this is the canonical companyId from workspace_list and is passed to the CLI as -C. Optional when the account has exactly one workspace.',
+                })),
+            }),
+            async execute(_toolCallId, params) {
+                const err = await ensureReady();
+                if (err)
+                    return textResult(err);
+                try {
+                    const projects = await getProvider().listProjects(params.workspaceId);
+                    if (projects.length === 0)
+                        return textResult('No projects found.');
+                    return textResult(JSON.stringify(projects, null, 2));
+                }
+                catch (error) {
+                    return textResult(`Error: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            },
+        }),
+        defineTool({
+            name: 'user_directory_list',
+            label: 'Teamwork',
+            description: 'List assignable AMaster users or members in the current teamwork workspace. This is read-only and helps choose assignees.',
+            parameters: Type.Object({
+                workspaceId: Type.Optional(Type.String({
+                    description: 'Workspace ID. For AMaster provider this is the canonical companyId from workspace_list and is passed to the CLI as -C. Optional when the account has exactly one workspace.',
+                })),
+                q: Type.Optional(Type.String({ description: 'Optional search text.' })),
+                limit: Type.Optional(Type.Number({ description: 'Max number of results.' })),
+            }),
+            async execute(_toolCallId, params) {
+                const err = await ensureReady();
+                if (err)
+                    return textResult(err);
+                const activeProvider = getProvider();
+                if (!activeProvider.listUserDirectory) {
+                    return textResult('The current teamwork provider does not support user_directory_list.');
+                }
+                try {
+                    const users = await activeProvider.listUserDirectory(params);
+                    if (users.length === 0)
+                        return textResult('No assignable users found.');
+                    return textResult(JSON.stringify(users, null, 2));
+                }
+                catch (error) {
+                    return textResult(`Error: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            },
+        }),
+        defineTool({
+            name: 'teamwork_status',
+            label: 'Teamwork',
+            description: 'Check the status of the teamwork collaboration provider (daemon status, connected agents, etc.).',
+            parameters: Type.Object({}),
+            async execute() {
+                const err = await ensureReady();
+                if (err)
+                    return textResult(err);
+                try {
+                    const s = await getProvider().status();
+                    return textResult(JSON.stringify(s, null, 2));
+                }
+                catch (error) {
+                    return textResult(`Error: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            },
+        }),
+    ];
+}
+function supportedToolNamesForProvider(provider) {
+    const supportedToolNames = new Set(TEAMWORK_TOOL_ORDER);
+    if (!provider.listUserDirectory)
+        supportedToolNames.delete('user_directory_list');
+    return supportedToolNames;
+}
+function alignActiveTeamworkTools(pi, supportedToolNames, suspendedToolNames) {
+    try {
+        const activeToolNames = pi.getActiveTools();
+        const nextActiveToolNames = [];
+        for (const toolName of activeToolNames) {
+            if (!TEAMWORK_TOOL_NAMES.has(toolName) || supportedToolNames.has(toolName)) {
+                nextActiveToolNames.push(toolName);
+                if (supportedToolNames.has(toolName))
+                    suspendedToolNames.delete(toolName);
+                continue;
             }
-            catch (error) {
-                return textResult(`Error: ${error instanceof Error ? error.message : String(error)}`);
+            suspendedToolNames.add(toolName);
+        }
+        for (const toolName of TEAMWORK_TOOL_ORDER) {
+            if (supportedToolNames.has(toolName) &&
+                suspendedToolNames.has(toolName) &&
+                !nextActiveToolNames.includes(toolName)) {
+                nextActiveToolNames.push(toolName);
+                suspendedToolNames.delete(toolName);
             }
-        },
-    });
+        }
+        if (nextActiveToolNames.join('\0') !== activeToolNames.join('\0')) {
+            pi.setActiveTools(nextActiveToolNames);
+        }
+    }
+    catch {
+        // Older test harnesses and pre-session runtimes may not expose active tool controls.
+    }
 }
 function textResult(text) {
     return { content: [{ type: 'text', text }], details: undefined };
 }
+function execWithEnv(command, args, env, cwd) {
+    return new Promise((resolve) => {
+        const child = spawn(command, args, {
+            cwd,
+            shell: false,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: { ...process.env, ...env },
+        });
+        let stdout = '';
+        let stderr = '';
+        let settled = false;
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(result);
+        };
+        child.stdout?.on('data', (chunk) => {
+            stdout += String(chunk);
+        });
+        child.stderr?.on('data', (chunk) => {
+            stderr += String(chunk);
+        });
+        child.on('error', (error) => {
+            finish({ stdout, stderr: error.message, code: 1 });
+        });
+        child.on('close', (code) => {
+            finish({ stdout, stderr, code: code ?? 0 });
+        });
+    });
+}
 function loadConfig(cwd) {
     try {
         const config = loadPiSettings(SETTINGS_KEY, {
             cwd,
-            agentDir: resolveAgentDir(),
         });
         return Object.keys(config).length > 0 ? config : {};
     }