[FEATURE] Local Task Executor for Deterministic Operations

Preflight Checklist

• [x] I have searched existing requests and this feature hasn't been requested yet
• [x] This is a single feature request (not multiple features)

Problem Statement

Claude Code routes every deterministic file operation (Edit, Write) through the API as individual tool calls. Bulk mechanical tasks — 128 identical find-and-replace operations, for example — consume server compute and user token budget for work that requires zero inference. The model becomes a bottleneck for janitorial work it already solved intellectually.

Proposed Solution

Ship a local task executor as part of the Claude Code extension. The server session emits a structured task manifest; the local executor consumes it against the filesystem using the same sandbox, permissions, and git safety checks already in place. No round-trips, no token burn, no model inference.

Alternative Solutions

_No response_

Priority

High - Significant impact on productivity

Feature Category

Performance and speed

Use Case Example

Workflow

1. Server session performs analysis (reading, reasoning, classification).
2. Server emits a structured manifest describing deterministic operations:

{
  "task": "bulk-replace",
  "file": "src/foundation.jsx",
  "operations": [
    {"line": 712, "find": "new Error(", "replace": "new TypeError("},
    {"line": 995, "find": "new Error(", "replace": "new TypeError("},
    {"line": 1017, "find": "new Error(", "replace": "new RangeError("}
  ]
}

Local executor validates manifest against sandbox rules and permission mode.
Local executor applies operations, reports success/failure summary.
Server session resumes with outcome — no token cost for execution phase.

Why This Works

The Edit tool is already deterministic string replacement. The waste is in the routing, not the operation.
The extension binary already has filesystem access, sandbox infrastructure, and git safety checks.
The local executor doesn't need a model. It needs a task runner that parses a manifest and applies it. That's a script, not inference.

Scales to any bulk operation: renames, reformatting, boilerplate insertion, migration patterns.

Who Benefits

Users keep token budget for reasoning that actually needs a large model.
Anthropic saves server compute on operations that require none.
Latency drops from seconds-per-edit to milliseconds for bulk operations.

Real-World Example

In a single session, 128 error type corrections were identified across a 7900-line file. Analysis required Opus-level reasoning (context-dependent classification of each error). Execution was 128 identical one-word substitutions. The analysis consumed ~70% of the user's token budget. The user applied all 128 changes manually in 5 minutes using bookmarks and a text editor macro - faster than the model could have emitted the Edit calls.

Additional Context

_No response_