salmon-loop 0.3.0 → 0.3.2

package/dist/core/protocols/acp/handlers.js

@@ -12,7 +12,10 @@ export function createAcpSessionStore() {
                 createdAt: now,
                 updatedAt: now,
                 title: input.title,
+                permissionPolicy: input.permissionPolicy,
+                modeId: input.modeId,
                 history: [],
+                materialized: false,
                 cancelRequested: false,
             };
             sessions.set(id, session);

package/dist/core/protocols/acp/permission-provider.js

@@ -1,43 +1,15 @@
-function toToolKind(request) {
-    const name = request.toolName.toLowerCase();
-    if (name.includes('read') ||
-        name.includes('get') ||
-        name.includes('view') ||
-        name.includes('ls') ||
-        name.includes('list') ||
-        (request.sideEffects.length > 0 && request.sideEffects.every((e) => e === 'fs_read')))
-        return 'read';
-    if (name.includes('write') ||
-        name.includes('edit') ||
-        name.includes('patch') ||
-        request.sideEffects.includes('fs_write'))
-        return 'edit';
-    if (name.includes('delete') ||
-        name.includes('remove') ||
-        name.includes('rm') ||
-        request.sideEffects.includes('fs_delete'))
-        return 'delete';
-    if (name.includes('move') || name.includes('rename') || name.includes('mv'))
-        return 'move';
-    if (name.includes('grep') || name.includes('search') || name.includes('find'))
-        return 'search';
-    if (name.includes('run') ||
-        name.includes('exec') ||
-        name.includes('spawn') ||
-        request.sideEffects.includes('process'))
-        return 'execute';
-    if (name.includes('plan') || name.includes('think') || name.includes('reason'))
-        return 'think';
-    if (name.includes('fetch') || name.includes('curl') || name.includes('http'))
-        return 'fetch';
-    return 'other';
-}
+import { text } from '../../../locales/index.js';
+import { mapToolKind } from './tool-kind-mapping.js';
 function buildPermissionOptions() {
     return [
-        { kind: 'allow_once', name: 'Allow once', optionId: 'allow_once' },
-        { kind: 'allow_always', name: 'Allow for session', optionId: 'allow_always' },
-        { kind: 'reject_once', name: 'Reject once', optionId: 'reject_once' },
-        { kind: 'reject_always', name: 'Reject for session', optionId: 'reject_always' },
+        { kind: 'allow_once', name: text.acp.permissionOptionAllowOnce, optionId: 'allow_once' },
+        { kind: 'allow_always', name: text.acp.permissionOptionAllowSession, optionId: 'allow_always' },
+        { kind: 'reject_once', name: text.acp.permissionOptionRejectOnce, optionId: 'reject_once' },
+        {
+            kind: 'reject_always',
+            name: text.acp.permissionOptionRejectSession,
+            optionId: 'reject_always',
+        },
     ];
 }
 function toToolCallUpdate(request) {
@@ -48,7 +20,7 @@ function toToolCallUpdate(request) {
     return {
         toolCallId: request.id,
         title: request.toolName,
-        kind: toToolKind(request),
+        kind: mapToolKind(request.toolName, { sideEffects: request.sideEffects }),
         status: 'pending',
         rawInput: {
             toolName: request.toolName,

package/dist/core/protocols/acp/stdio-server.js

@@ -14,11 +14,21 @@ const PARSE_ERROR = {
 function isJsonObject(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
+function hasOwn(value, key) {
+    return Object.prototype.hasOwnProperty.call(value, key);
+}
 function formatLineSnippet(line, maxLength = 160) {
     if (line.length <= maxLength)
         return line;
     return `${line.slice(0, maxLength - 3)}...`;
 }
+function normalizeJsonRpcParams(message) {
+    if (typeof message.method !== 'string')
+        return;
+    if (!hasOwn(message, 'params') || message.params === null) {
+        message.params = {};
+    }
+}
 function safeWarn(message) {
     const logger = tryGetLogger();
     if (logger)
@@ -28,8 +38,12 @@ function createNdjsonWriter(output) {
     const writer = output.getWriter();
     const encoder = new TextEncoder();
     let tail = Promise.resolve();
+    let lastError;
     return {
         async write(message) {
+            if (lastError) {
+                throw lastError;
+            }
             const content = JSON.stringify(message) + '\n';
             const data = encoder.encode(content);
             tail = tail
@@ -38,6 +52,7 @@ function createNdjsonWriter(output) {
                 .catch((error) => {
                 const detail = error instanceof Error ? error.message : String(error);
                 safeWarn(`ACP stdio failed to write NDJSON line. reason="${detail}"`);
+                lastError = error instanceof Error ? new Error(detail) : new Error(detail);
             });
             await tail;
         },
@@ -58,6 +73,7 @@ async function processStdioLine(line, ndjson, controller) {
             await writeInvalidRequest(ndjson, trimmed);
             return;
         }
+        normalizeJsonRpcParams(parsed);
         if (parsed.params && typeof parsed.params === 'object' && !Array.isArray(parsed.params)) {
             const params = parsed.params;
             if (params.mcpServers === null) {
@@ -82,8 +98,10 @@ export function createAcpStdioStream(output, input) {
             try {
                 while (true) {
                     const { value, done } = await reader.read();
-                    if (done)
+                    if (done) {
+                        buffer += textDecoder.decode();
                         break;
+                    }
                     if (!value)
                         continue;
                     buffer += textDecoder.decode(value, { stream: true });
@@ -93,6 +111,7 @@ export function createAcpStdioStream(output, input) {
                         await processStdioLine(line, ndjson, controller);
                     }
                 }
+                await processStdioLine(buffer, ndjson, controller);
             }
             finally {
                 reader.releaseLock();

package/dist/core/protocols/acp/tool-kind-mapping.js

@@ -0,0 +1,62 @@
+/**
+ * Maps a tool name and optional metadata to an ACP ToolKind.
+ *
+ * Priority: explicit intent > side-effect inference > name heuristics.
+ *
+ * Covers all 10 protocol-defined kinds:
+ * read | edit | delete | move | search | execute | think | fetch | switch_mode | other
+ */
+export function mapToolKind(toolName, options) {
+    const intent = options?.intent;
+    if (intent) {
+        switch (intent.toUpperCase()) {
+            case 'READ':
+            case 'LIST':
+                return 'read';
+            case 'SEARCH':
+                return 'search';
+            case 'WRITE':
+                return 'edit';
+            case 'INFRA':
+                return 'execute';
+            case 'AGENT':
+                return 'think';
+        }
+    }
+    const sideEffects = options?.sideEffects;
+    if (sideEffects && sideEffects.length > 0) {
+        if (sideEffects.every((e) => e === 'fs_read'))
+            return 'read';
+        if (sideEffects.includes('fs_write'))
+            return 'edit';
+        if (sideEffects.includes('fs_delete'))
+            return 'delete';
+        if (sideEffects.includes('process'))
+            return 'execute';
+    }
+    const name = toolName.toLowerCase();
+    if (name.includes('read') ||
+        name.includes('get') ||
+        name.includes('view') ||
+        name.includes('ls') ||
+        name.includes('list'))
+        return 'read';
+    if (name.includes('write') || name.includes('edit') || name.includes('patch'))
+        return 'edit';
+    if (name.includes('delete') || name.includes('remove') || name.includes('rm'))
+        return 'delete';
+    if (name.includes('move') || name.includes('rename') || name.includes('mv'))
+        return 'move';
+    if (name.includes('grep') || name.includes('search') || name.includes('find'))
+        return 'search';
+    if (name.includes('run') || name.includes('exec') || name.includes('spawn'))
+        return 'execute';
+    if (name.includes('plan') || name.includes('think') || name.includes('reason'))
+        return 'think';
+    if (name.includes('fetch') || name.includes('curl') || name.includes('http'))
+        return 'fetch';
+    if (name.includes('mode') || name.includes('switch'))
+        return 'switch_mode';
+    return 'other';
+}
+//# sourceMappingURL=tool-kind-mapping.js.map

package/dist/core/protocols/shared/flow-mode-mapping.js

@@ -1,4 +1,3 @@
-import { FLOW_MODE_PUBLIC_METADATA } from '../../public-capabilities/flow-mode-metadata.js';
 import { FLOW_MODES, parseFlowMode } from '../../types/flow-mode.js';
 export const SUPPORTED_PROTOCOL_FLOW_MODES = FLOW_MODES;
 export function parseAcpFlowMode(value) {
@@ -13,11 +12,4 @@ export function parseAcpFlowMode(value) {
 export function parseA2ASkillFlowMode(value) {
     return parseFlowMode(value);
 }
-export function buildA2AFlowSkills() {
-    return SUPPORTED_PROTOCOL_FLOW_MODES.map((mode) => ({
-        id: mode,
-        title: FLOW_MODE_PUBLIC_METADATA[mode].a2aTitle,
-        description: FLOW_MODE_PUBLIC_METADATA[mode].description,
-    }));
-}
 //# sourceMappingURL=flow-mode-mapping.js.map

package/dist/core/public-capabilities/flow-mode-metadata.js

@@ -1,37 +1,31 @@
 export const FLOW_MODE_PUBLIC_METADATA = {
     autopilot: {
         publicTitle: 'Autopilot',
-        a2aTitle: 'Autopilot',
         acpName: 'Autopilot',
         description: 'Let the agent decide which actions and tools to use.',
     },
     patch: {
         publicTitle: 'Patch code',
-        a2aTitle: 'Patch code',
         acpName: 'Patch',
         description: 'Apply code changes with verification.',
     },
     review: {
         publicTitle: 'Review code',
-        a2aTitle: 'Review code',
         acpName: 'Review',
         description: 'Inspect code and report findings without mutating files.',
     },
     debug: {
         publicTitle: 'Debug issue',
-        a2aTitle: 'Debug issue',
         acpName: 'Debug',
         description: 'Investigate issues and make targeted fixes when needed.',
     },
     research: {
         publicTitle: 'Research request',
-        a2aTitle: 'Research request',
         acpName: 'Research',
         description: 'Explore the codebase and summarize relevant findings.',
     },
     answer: {
         publicTitle: 'Answer question',
-        a2aTitle: 'Answer question',
         acpName: 'Answer',
         description: 'Answer questions directly without editing files.',
     },

package/dist/core/public-capabilities/projections.js

@@ -24,6 +24,7 @@ export function toA2APublicSkills(entries = buildPublicCapabilityRegistry()) {
         examples: entry.examples,
         inputModes: entry.inputModes,
         outputModes: entry.outputModes,
+        security: entry.security,
     }));
 }
 //# sourceMappingURL=projections.js.map

package/dist/core/runtime/agent-server-runtime.js

@@ -1,11 +1,10 @@
-import { InMemoryTaskStore } from '@a2a-js/sdk/server';
 import { createTaskEventBus } from '../interaction/events/bus.js';
 import { createInteractionFacade } from '../interaction/orchestration/facade.js';
 import { createA2AInteractionExecutor } from '../protocols/a2a/sdk/executor.js';
-import { createA2ASdkExpressApp } from '../protocols/a2a/sdk/server.js';
+import { createA2ASdkExpressApp, ProtocolAlignedInMemoryTaskStore, } from '../protocols/a2a/sdk/server.js';
 export function createAgentServerRuntime(deps) {
     const eventBus = deps.a2a.eventBus ?? createTaskEventBus();
-    const taskStore = deps.a2a.taskStore ?? new InMemoryTaskStore();
+    const taskStore = deps.a2a.taskStore ?? new ProtocolAlignedInMemoryTaskStore();
     const facade = createInteractionFacade({
         executeTask: deps.a2a.executeTask,
         eventBus,

package/dist/core/runtime/spawn-command.js

@@ -349,14 +349,20 @@ async function spawnWithNode(input) {
             timeoutTimer = setTimeout(() => {
                 timedOut = true;
                 killProcess('SIGTERM');
-                killTimer = setTimeout(() => killProcess('SIGKILL'), killGraceMs);
+                killTimer = setTimeout(() => {
+                    killProcess('SIGKILL');
+                    settle(null, null);
+                }, killGraceMs);
             }, input.timeoutMs);
         }
         if (input.signal) {
             onAbort = () => {
                 aborted = true;
                 killProcess('SIGTERM');
-                killTimer = setTimeout(() => killProcess('SIGKILL'), input.killGraceMs ?? 2000);
+                killTimer = setTimeout(() => {
+                    killProcess('SIGKILL');
+                    settle(null, null);
+                }, input.killGraceMs ?? 2000);
             };
             input.signal.addEventListener('abort', onAbort, { once: true });
         }

package/dist/core/runtime/spawn-interactive.js

@@ -14,15 +14,22 @@ export function spawnInteractiveProcess(input) {
             windowsHide: input.windowsHide,
         });
         const events = new EventEmitter();
+        let exitCode;
+        queueMicrotask(() => events.emit('spawn'));
         void subprocess.exited
             .then((code) => {
+            exitCode = code;
             events.emit('exit', code, normalizeSignal(subprocess.signalCode));
+            events.emit('close', code, normalizeSignal(subprocess.signalCode));
         })
             .catch((error) => {
             events.emit('error', error);
         });
         const processRef = {
             pid: subprocess.pid,
+            get exitCode() {
+                return exitCode ?? null;
+            },
             stdin: subprocess.stdin ?? undefined,
             stdout: toNodeReadableStream(subprocess.stdout),
             stderr: toNodeReadableStream(subprocess.stderr),
@@ -38,6 +45,14 @@ export function spawnInteractiveProcess(input) {
                 events.on(event, listener);
                 return processRef;
             },
+            once: (event, listener) => {
+                events.once(event, listener);
+                return processRef;
+            },
+            off: (event, listener) => {
+                events.off(event, listener);
+                return processRef;
+            },
         };
         return processRef;
     }
@@ -50,6 +65,9 @@ export function spawnInteractiveProcess(input) {
     });
     const processRef = {
         pid: child.pid,
+        get exitCode() {
+            return child.exitCode;
+        },
         stdin: child.stdin ?? undefined,
         stdout: child.stdout ?? undefined,
         stderr: child.stderr ?? undefined,
@@ -65,6 +83,14 @@ export function spawnInteractiveProcess(input) {
             child.on(event, listener);
             return processRef;
         },
+        once: (event, listener) => {
+            child.once(event, listener);
+            return processRef;
+        },
+        off: (event, listener) => {
+            child.off(event, listener);
+            return processRef;
+        },
     };
     return processRef;
 }

package/dist/core/session/manager.js

@@ -45,6 +45,7 @@ function normalizeChatState(chatState) {
  * Features: Auto-pruning, compression, intelligent cleanup
  */
 export class ChatSessionManager {
+    static FILE_READ_CHUNK_SIZE = 10;
     repoPath;
     storageDir;
     currentSession = null;
@@ -268,18 +269,32 @@ export class ChatSessionManager {
      */
     async listSessions() {
         const files = await this.fileAdapter.readdir(this.storageDir).catch(() => []);
+        const jsonFiles = files.filter((f) => f.endsWith('.json'));
         const sessions = [];
-        for (const file of files) {
-            if (!file.endsWith('.json'))
-                continue;
-            const filePath = join(this.storageDir, file);
-            const data = await this.fileAdapter.readFile(filePath);
-            const session = JSON.parse(data);
-            sessions.push({
-                id: session.meta.id,
-                name: session.meta.name,
-                updatedAt: session.meta.updatedAt,
+        for (let i = 0; i < jsonFiles.length; i += ChatSessionManager.FILE_READ_CHUNK_SIZE) {
+            const chunk = jsonFiles.slice(i, i + ChatSessionManager.FILE_READ_CHUNK_SIZE);
+            const promises = chunk.map(async (file) => {
+                try {
+                    const filePath = join(this.storageDir, file);
+                    const data = await this.fileAdapter.readFile(filePath);
+                    const session = JSON.parse(data);
+                    return {
+                        id: session.meta.id,
+                        name: session.meta.name,
+                        updatedAt: session.meta.updatedAt,
+                    };
+                }
+                catch (error) {
+                    getLogger().warn(`Failed to list session file ${file}: ${error}`);
+                    return null;
+                }
             });
+            const results = await Promise.all(promises);
+            for (const result of results) {
+                if (result) {
+                    sessions.push(result);
+                }
+            }
         }
         return sessions.sort((a, b) => b.updatedAt - a.updatedAt);
     }
@@ -291,19 +306,26 @@ export class ChatSessionManager {
         const analysis = this.pruningEngine.analyzeSessions(sessions);
         let deleted = 0;
         let archived = 0;
+        const CHUNK_SIZE = 10;
         // Delete low-priority sessions
-        for (const sessionId of analysis.sessionsToDelete) {
-            await this.deleteSession(sessionId);
-            deleted++;
+        for (let i = 0; i < analysis.sessionsToDelete.length; i += CHUNK_SIZE) {
+            const chunk = analysis.sessionsToDelete.slice(i, i + CHUNK_SIZE);
+            await Promise.all(chunk.map(async (sessionId) => {
+                await this.deleteSession(sessionId);
+                deleted++;
+            }));
         }
         // Archive medium-priority sessions
-        for (const sessionId of analysis.sessionsToArchive) {
-            const session = sessions.find((s) => s.meta.id === sessionId);
-            if (session) {
-                await this.archiveSession(session);
-                await this.deleteSession(sessionId);
-                archived++;
-            }
+        for (let i = 0; i < analysis.sessionsToArchive.length; i += CHUNK_SIZE) {
+            const chunk = analysis.sessionsToArchive.slice(i, i + CHUNK_SIZE);
+            await Promise.all(chunk.map(async (sessionId) => {
+                const session = sessions.find((s) => s.meta.id === sessionId);
+                if (session) {
+                    await this.archiveSession(session);
+                    await this.deleteSession(sessionId);
+                    archived++;
+                }
+            }));
         }
         return {
             deleted,
@@ -323,22 +345,30 @@ export class ChatSessionManager {
      */
     async loadAllSessions() {
         const files = await this.fileAdapter.readdir(this.storageDir).catch(() => []);
+        const jsonFiles = files.filter((f) => f.endsWith('.json'));
         const sessions = [];
-        for (const file of files) {
-            if (!file.endsWith('.json'))
-                continue;
-            try {
-                const filePath = join(this.storageDir, file);
-                const data = await this.fileAdapter.readFile(filePath);
-                const session = JSON.parse(data);
-                session.meta.chatState = normalizeChatState(session.meta.chatState);
-                session.meta.artifactState = normalizeSessionArtifactState(session.meta.artifactState);
-                session.meta.replacementState = normalizeToolResultReplacementState(session.meta.replacementState);
-                sessions.push(session);
-            }
-            catch (error) {
-                // Skip corrupted session files
-                getLogger().warn(`Failed to load session file ${file}: ${error}`);
+        for (let i = 0; i < jsonFiles.length; i += ChatSessionManager.FILE_READ_CHUNK_SIZE) {
+            const chunk = jsonFiles.slice(i, i + ChatSessionManager.FILE_READ_CHUNK_SIZE);
+            const promises = chunk.map(async (file) => {
+                try {
+                    const filePath = join(this.storageDir, file);
+                    const data = await this.fileAdapter.readFile(filePath);
+                    const session = JSON.parse(data);
+                    session.meta.chatState = normalizeChatState(session.meta.chatState);
+                    session.meta.artifactState = normalizeSessionArtifactState(session.meta.artifactState);
+                    session.meta.replacementState = normalizeToolResultReplacementState(session.meta.replacementState);
+                    return session;
+                }
+                catch (error) {
+                    getLogger().warn(`Failed to load session file ${file}: ${error}`);
+                    return null;
+                }
+            });
+            const results = await Promise.all(promises);
+            for (const result of results) {
+                if (result) {
+                    sessions.push(result);
+                }
             }
         }
         return sessions;

package/dist/core/tools/builtin/index.js

@@ -13,6 +13,7 @@ import { planInitSpec, planReadSpec, planUpdateSpec } from './plan.js';
 import { proposalApplySpec, executeProposalApply } from './proposal.js';
 import { shellExecSpec, executeShellExec } from './shell.js';
 import { verifyRunSpec, executeVerifyRun } from './verify.js';
+import { workspaceInfoSpec, executeWorkspaceInfo } from './workspace.js';
 /**
  * Registers all builtin tools into the provided registry
  */
@@ -27,6 +28,10 @@ export function registerAllBuiltins(registry) {
         ...updateKnowledgeSpec,
         executor: executeUpdateKnowledge,
     });
+    registry.register({
+        ...workspaceInfoSpec,
+        executor: executeWorkspaceInfo,
+    });
     registry.register({
         ...proposalApplySpec,
         executor: executeProposalApply,
@@ -125,5 +130,5 @@ export function registerAllBuiltins(registry) {
     registry.register(planUpdateSpec);
     registry.register(askUserSpec);
 }
-export { CodeSearchSpec, codeSearchExecutor, astDefsRefsSpec as codeAstSpec, executeAstDefsRefs as executeCodeAst, gitCatSpec, executeGitCat, gitStatusSpec, executeGitStatus, codeReadSpec, fsListSpec, executeFsList, fsReadFileSpec as fsReadSpec, executeFsReadFile as executeFsRead, updateKnowledgeSpec, executeUpdateKnowledge, astGrepSpec as codeSearchAstSpec, executeAstGrep as executeCodeSearchAst, verifyRunSpec as testRunSpec, executeVerifyRun as executeTestRun, gitDiffCheckSpec, executeGitDiffCheck, gitApplyCheckSpec, executeGitApplyCheck, benchmarkReportSpec, executeBenchmarkReport, sweBenchLoadInstanceSpec, executeSweBenchLoadInstance, sweBenchWritePredictionSpec, executeSweBenchWritePrediction, sweBenchSubmitPredictionsSpec, executeSweBenchSubmitPredictions, sweBenchGetReportSpec, executeSweBenchGetReport, };
+export { CodeSearchSpec, codeSearchExecutor, astDefsRefsSpec as codeAstSpec, executeAstDefsRefs as executeCodeAst, gitCatSpec, executeGitCat, gitStatusSpec, executeGitStatus, codeReadSpec, fsListSpec, executeFsList, fsReadFileSpec as fsReadSpec, executeFsReadFile as executeFsRead, updateKnowledgeSpec, executeUpdateKnowledge, astGrepSpec as codeSearchAstSpec, executeAstGrep as executeCodeSearchAst, verifyRunSpec as testRunSpec, executeVerifyRun as executeTestRun, gitDiffCheckSpec, executeGitDiffCheck, gitApplyCheckSpec, executeGitApplyCheck, benchmarkReportSpec, executeBenchmarkReport, sweBenchLoadInstanceSpec, executeSweBenchLoadInstance, sweBenchWritePredictionSpec, executeSweBenchWritePrediction, sweBenchSubmitPredictionsSpec, executeSweBenchSubmitPredictions, sweBenchGetReportSpec, executeSweBenchGetReport, workspaceInfoSpec, executeWorkspaceInfo, };
 //# sourceMappingURL=index.js.map

package/dist/core/tools/builtin/proposal.js

@@ -7,10 +7,7 @@ import { DecisionEngine, PlanBuilder } from '../../grizzco/dsl/DecisionEngine.js
 import { StandardStrategy } from '../../grizzco/dsl/strategies.js';
 import { Executor } from '../../grizzco/execution/Executor.js';
 import { WorkerFactory } from '../../grizzco/execution/WorkerFactory.js';
-import { CachedService } from '../../grizzco/services/CachedService.js';
-import { GitConfigService } from '../../grizzco/services/implementations/default/GitConfigService.js';
 import { MockLockService } from '../../grizzco/services/implementations/mock/MockLockService.js';
-import { MockUserQuotaService } from '../../grizzco/services/implementations/mock/MockUserQuotaService.js';
 import { registry } from '../../grizzco/services/registry.js';
 import { normalizeDiff, validateDiff, convertDiffToShadowOperations } from '../../patch/diff.js';
 import { getRejectionsDir } from '../../runtime/paths.js';
@@ -20,10 +17,6 @@ import { Phase } from '../../types/runtime.js';
 function bootstrapRegistry() {
     if (!registry.has('remote_lock'))
         registry.register(new MockLockService());
-    if (!registry.has('user_quota'))
-        registry.register(new MockUserQuotaService());
-    if (!registry.has('git_config'))
-        registry.register(new CachedService(new GitConfigService()));
 }
 export const proposalApplySpec = {
     name: 'proposal.apply',

package/dist/core/tools/builtin/workspace.js

@@ -0,0 +1,76 @@
+import { z } from 'zod';
+import { Phase } from '../../types/runtime.js';
+import { detectWorkspaceCapabilities } from '../../workspace/capabilities.js';
+const WorkspaceCapabilitiesOutputSchema = z.object({
+    root: z.string(),
+    capabilities: z.object({
+        git: z.object({
+            available: z.boolean(),
+            insideWorkTree: z.boolean(),
+            head: z.string().optional(),
+            reason: z.string().optional(),
+        }),
+        filesystem: z.object({
+            readable: z.boolean(),
+            writable: z.boolean(),
+            reason: z.string().optional(),
+        }),
+    }),
+    guidance: z.object({
+        useGitTools: z.boolean(),
+        useFilesystemReadTools: z.boolean(),
+        useFilesystemWriteTools: z.boolean(),
+    }),
+});
+export const workspaceInfoSpec = {
+    name: 'workspace.info',
+    source: 'builtin',
+    intent: 'READ',
+    description: 'Report the current workspace root and available capabilities, including whether git tools are usable.',
+    riskLevel: 'low',
+    sideEffects: ['none'],
+    concurrency: 'parallel_ok',
+    inputSchema: z.object({}),
+    outputSchema: WorkspaceCapabilitiesOutputSchema,
+    allowedPhases: [
+        Phase.SLASH,
+        Phase.CONTEXT,
+        Phase.EXPLORE,
+        Phase.PLAN,
+        Phase.AUTOPILOT,
+        Phase.PATCH,
+        Phase.VERIFY,
+        Phase.SHRINK,
+    ],
+    examples: [
+        {
+            description: 'Check whether git tools are available before calling git.status',
+            input: {},
+            output: {
+                root: '/workspace/project',
+                capabilities: {
+                    git: { available: true, insideWorkTree: true, head: '<commit>' },
+                    filesystem: { readable: true, writable: true },
+                },
+                guidance: {
+                    useGitTools: true,
+                    useFilesystemReadTools: true,
+                    useFilesystemWriteTools: true,
+                },
+            },
+        },
+    ],
+};
+export async function executeWorkspaceInfo(_input, ctx) {
+    const capabilities = ctx.workspaceCapabilities ?? (await detectWorkspaceCapabilities(ctx.repoRoot));
+    return {
+        root: ctx.repoRoot,
+        capabilities,
+        guidance: {
+            useGitTools: capabilities.git.available && capabilities.git.insideWorkTree,
+            useFilesystemReadTools: capabilities.filesystem.readable,
+            useFilesystemWriteTools: capabilities.filesystem.writable,
+        },
+    };
+}
+//# sourceMappingURL=workspace.js.map

package/dist/core/tools/dispatcher.js

@@ -40,6 +40,7 @@ export class ToolDispatcher {
                     repoRoot: this.options.repoRoot,
                     persistenceRoot: this.options.persistenceRoot,
                     worktreeRoot: this.options.worktreeRoot,
+                    workspaceCapabilities: this.options.workspaceCapabilities,
                     attemptId: this.options.attemptId,
                     dryRun: this.options.dryRun,
                     model: this.options.model,