baxian 2.0.6 → 2.0.7

package/dist/agent/manager.js

@@ -6,8 +6,8 @@ import { tmpdir } from 'node:os';
 import { createSignalToken, PASSIVE_VERDICT_WATCH } from './phase-signal.js';
 import { tmuxInstallHint } from './preflight.js';
 import { BRANCH_PREFIX, isValidBranchName, PHASE_EXPECTED_STATUS, PHASE_REQUIRES_AGENT_BOUND_TO_TASK, TASK_TERMINAL_STATUSES as TERMINAL_STATUSES, TASK_ACTIVE_STATUS_SET as ACTIVE_TASK_STATUSES, TASK_OWNER_ROLES, effectiveTaskReviewRound, isSpecStagePhase, isTaskOpen, repoIdentityKey, taskAttentionGeneration, taskGenerationGuard, taskReviewRound, taskMatchesGeneration, } from '../shared/index.js';
-import { buildProjectDriver, makeDriverExec } from '../platform/driver-host.js';
-import { DriverOpError, buildDriverRunContext, GitDriver, safeDriverErrorText } from '../platform/git-driver.js';
+import { buildProjectDriver, buildProjectPromptContext, makeDriverExec, } from '../platform/driver-host.js';
+import { DriverOpError, safeDriverErrorText, validateCommentBody, } from '../platform/types.js';
 import { versionTimeOf } from '../platform/row-schema.js';
 import { checkOpenPrBinding, checkPrBinding } from '../platform/pr-binding.js';
 import { collectPendingFeedback, scanCommentSourcesOnce } from '../platform/feedback.js';
@@ -15,21 +15,18 @@ import { prReviewCacheRevision } from '../platform/pr-conversation-cache.js';
 import { deadTokens, recheckPassProvenance } from '../platform/verdict-engine.js';
 import { platformBindingMismatch, taskNeedsPlatformBindingAudit, } from '../platform/startup.js';
 import { AGENT_STORE_NOOP } from '../state/agent-store.js';
-import { SkillRegistry } from '../skill/registry.js';
-import { createRunner, LocalRunner, shellQuote, resolveAgentHost, hostGroupKey, workdirHostGroupKey, } from './runner.js';
-import { execOutcomeUnknown, isTransientNetworkFailure } from './net-exec.js';
+import { createRunner, LocalRunner, shellQuote, resolveAgentHost, workdirHostGroupKey, } from './runner.js';
+import { isTransientNetworkFailure } from './net-exec.js';
 import { imageFilename, agentHostPath, writeImageToHost } from './image-input.js';
 import { TmuxManager, ReplNotReadyError, detectStartupDialog, detectRuntimeMenu, runtimeBusyCheck, hasRuntimeReadyView, hasReplProcTitle, hasOscTitleWorking, hasOscTitleIdle, screenAllowsTitleIdle, PaneGoneError, } from './tmux.js';
 import { BranchManager, DirtyWorkdirError, ReviewHeadMismatchError, isAutoDeletableTaskBranch } from './branch.js';
-import { RepoStore, createRepoStoreCache, moveFileIntoPlace, stageFile, trashBatchDirUnder } from './repo-store.js';
+import { RepoStore, createRepoStoreCache } from './repo-store.js';
 import { PhaseSignalWatcher, } from './phase-signal-watcher.js';
-import { buildPromptInline, buildGreetingPrompt, PromptSizeError, RequiredSkillsMissingError, MAX_PROMPT_BYTES_ROUTE_LIMIT, } from './prompt.js';
+import { buildPromptInline, buildGreetingPrompt, PromptSizeError, MAX_PROMPT_BYTES_ROUTE_LIMIT, } from './prompt.js';
 import { ApiError } from '../errors.js';
 import { prepareConfig } from '../config/loader.js';
-import { resolveProjectTool } from '../config/validator.js';
 import { SHA_HEX_SOURCE } from '../platform/types.js';
 import { bodyDigest } from '../platform/body-digest.js';
-import { validateCommentBody } from '../platform/command-renderer.js';
 import { buildReviewTokenLine, extractReviewTokens, rowTokens } from '../platform/markers.js';
 const BENIGN_DISPATCH_CONFLICT_CODES = new Set(['dispatch-superseded', 'dispatch-in-flight']);
 export function isBenignDispatchConflict(err) {
@@ -127,6 +124,7 @@ const REPL_EXIT_COMMAND = {
     qodercli: '/quit',
 };
 const WORKDIR_SESSION_OPTION = '@baxian-workdir';
+const TASK_CONTEXT_SESSION_OPTION = '@baxian-context-task-id';
 function normalizedDir(left) {
     if (!left)
         return null;
@@ -147,17 +145,6 @@ async function sameDirOnHost(runner, left, right) {
     };
     return await physical(left) === await physical(right);
 }
-export function skillSubdirFor(runtime) {
-    switch (runtime) {
-        case 'codex':
-        case 'opencode':
-            return '.agents/skills';
-        case 'qodercli':
-            return '.qoder/skills';
-        default:
-            return '.claude/skills';
-    }
-}
 const DEFAULT_DISPATCH_ACK_TIMEOUT_MS = 30_000;
 const DEFAULT_NEED_INPUT_RETRY_INTERVAL_MS = 5_000;
 const DEFAULT_DISPATCH_SETTLE_TIMEOUT_MS = 3_000;
@@ -184,7 +171,7 @@ const RUNTIME_LIVENESS_SAMPLES = 3;
 export function canDispatchWithBinding(binding) {
     return !binding?.taskId && !binding?.creationToken && binding?.status !== 'awaiting_human';
 }
-export const RECOVERABLE_QA_DISPATCH_HOLD_PHASES = new Set([
+const RECOVERABLE_QA_DISPATCH_HOLD_PHASES = new Set([
     'checkout-preparation-failed',
     'dirty-workdir',
 ]);
@@ -233,12 +220,10 @@ export class AgentManager {
     taskStore;
     lockManager;
     eventBus;
-    skillRegistry;
     runnerFactory;
     repoStoreFactory;
     repoCache;
     paneStreamerManager;
-    pluginRegistry;
     platformDefaultBranchOf;
     prConversationCache;
     platformDriverExec;
@@ -277,7 +262,7 @@ export class AgentManager {
     divergedAgents = new Set();
     deletionGeneration = new Map();
     compactInFlight = new Set();
-    configInterventionKeys = new Set();
+    platformBindingInterventionKeys = new Set();
     constructor(deps) {
         const config = prepareConfig(deps.config);
         this.config = config;
@@ -285,11 +270,9 @@ export class AgentManager {
         this.taskStore = deps.taskStore;
         this.lockManager = deps.lockManager;
         this.eventBus = deps.eventBus;
-        this.skillRegistry = deps.skillRegistry ?? new SkillRegistry();
         this.runnerFactory = deps.runnerFactory;
         this.repoStoreFactory = deps.repoStoreFactory;
         this.paneStreamerManager = deps.paneStreamerManager;
-        this.pluginRegistry = deps.pluginRegistry;
         this.platformDefaultBranchOf = deps.platformDefaultBranchOf;
         this.prConversationCache = deps.prConversationCache;
         this.errorRecordStore = deps.errorRecordStore;
@@ -415,30 +398,19 @@ export class AgentManager {
             data,
         });
     }
-    async emitConfigIntervention(projectId, data) {
-        const key = this.configInterventionKey(projectId, data);
-        if (this.configInterventionKeys.has(key))
-            return;
-        if (await this.emitIntervention(projectId, undefined, undefined, data)) {
-            this.configInterventionKeys.add(key);
-        }
-    }
-    configInterventionKey(projectId, data) {
-        return `config:${projectId}:${JSON.stringify(data)}`;
-    }
     platformBindingInterventionKey(task, mismatch) {
         return `binding:${task.id}:${mismatch.reason}:${mismatch.differences.join(',')}:` +
             `${JSON.stringify(mismatch.binding ?? null)}:${JSON.stringify(mismatch.live ?? null)}`;
     }
-    retainConfigInterventionKeys(keys) {
-        for (const key of this.configInterventionKeys) {
+    retainPlatformBindingInterventionKeys(keys) {
+        for (const key of this.platformBindingInterventionKeys) {
             if (!keys.has(key))
-                this.configInterventionKeys.delete(key);
+                this.platformBindingInterventionKeys.delete(key);
         }
     }
     async emitPlatformBindingIntervention(task, mismatch) {
         const key = this.platformBindingInterventionKey(task, mismatch);
-        if (this.configInterventionKeys.has(key))
+        if (this.platformBindingInterventionKeys.has(key))
             return;
         const emitted = await this.emitIntervention(task.projectId, task.agentId || undefined, task.id, {
             phase: 'platform-binding-mismatch',
@@ -448,7 +420,7 @@ export class AgentManager {
             ...(mismatch.live !== undefined ? { live: mismatch.live } : {}),
         });
         if (emitted)
-            this.configInterventionKeys.add(key);
+            this.platformBindingInterventionKeys.add(key);
     }
     async recordError(input) {
         if (!this.errorRecordStore)
@@ -606,13 +578,6 @@ export class AgentManager {
             return { ...existing, workdir, updatedAt: new Date().toISOString() };
         });
         assertGenerationOpen();
-        try {
-            await this.provisionRepoSkills(runner, agent, workdir);
-        }
-        catch (err) {
-            throw new EnsureSessionError({ createdSession: false, agentId }, `skill provisioning failed: ${err instanceof Error ? err.message : String(err)}`);
-        }
-        assertGenerationOpen();
         let snapshot;
         try {
             snapshot = await tmux.getSessionSnapshot(agentId);
@@ -641,31 +606,6 @@ export class AgentManager {
         }
         return this.adoptOrRestartSessionLocked(tmux, runner, agent, agentId, workdir, workdir, snapshot);
     }
-    agentSkillScope(agentId) {
-        const projectId = this.getAgentConfig(agentId)?.projectId;
-        if (projectId === undefined)
-            return { pluginTools: [] };
-        const project = this.getProjectConfig(projectId);
-        const tool = project === undefined ? undefined : resolveProjectTool(project);
-        return { pluginTools: tool === undefined ? [] : [tool] };
-    }
-    async provisionRepoSkills(runner, agent, workdir) {
-        if (this.skillRegistry.names().length === 0)
-            return;
-        const scope = this.agentSkillScope(agent.id);
-        const subdir = skillSubdirFor(agent.runtime);
-        const destRoot = `${workdir}/${subdir}`;
-        await this.excludeInjectedSkills(runner, workdir, subdir);
-        // Batch inside the swept tree itself: a symlinked skills dir may live on another filesystem, where mv degrades to copy+unlink.
-        const trashDir = trashBatchDirUnder(`${destRoot}/.baxian-trash`, 'skills');
-        await this.runUnderSkillDirLock(this.skillDirLockKey(agent, workdir), async () => {
-            await this.ensureSkillDirSafe(runner, workdir, subdir, [
-                ...this.skillRegistry.names(),
-                ...this.skillRegistry.pluginSkillNames(scope),
-            ], trashDir);
-            await this.skillRegistry.materialize((path, content) => this.atomicWriteFile(runner, path, content, trashDir), destRoot, scope);
-        });
-    }
     sessionLifecycleChain = new Map();
     adoptGeneration = new Map();
     runUnderSessionLifecycle(agentId, fn) {
@@ -733,109 +673,6 @@ export class AgentManager {
             return;
         await this.rollbackCreatedSession(agentId, err.partial, reason);
     }
-    skillDirChain = new Map();
-    skillDirLockKey(agent, workdir) {
-        const host = hostGroupKey(agent.mode, resolveAgentHost(this.config.host, agent.host));
-        const subdir = skillSubdirFor(agent.runtime);
-        const dir = workdir.replace(/\/+$/, '');
-        return `${host}:${dir}:${subdir}`;
-    }
-    runUnderSkillDirLock(key, fn) {
-        const prev = this.skillDirChain.get(key) ?? Promise.resolve();
-        const run = prev.then(fn, fn);
-        const settled = run.then(() => undefined, () => undefined);
-        this.skillDirChain.set(key, settled);
-        void settled.finally(() => {
-            if (this.skillDirChain.get(key) === settled)
-                this.skillDirChain.delete(key);
-        });
-        return run;
-    }
-    async atomicWriteFile(runner, finalPath, content, trashDir) {
-        const tmp = `${finalPath}.baxian-tmp-${randomBytes(6).toString('hex')}`;
-        try {
-            await stageFile(runner, tmp, content, { trashDir });
-            await moveFileIntoPlace(runner, tmp, finalPath, { trashDir });
-        }
-        catch (err) {
-            throw new Error(`atomic skill write failed (${finalPath}): ${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
-    async ensureSkillDirSafe(runner, workdir, subdir, keepNames, trashDir) {
-        const SKILLS_SWEPT = 'BX_SKILLS_SWEPT';
-        const keep = keepNames.map((n) => `! -name ${shellQuote(n)}`).join(' ');
-        const batch = shellQuote(trashDir);
-        // Stale directories go first so the later link/file passes only see what stayed behind in kept dirs. -H follows a symlinked skills dir given as the start path; -exec … + propagates a mover failure into find's exit code (\; would swallow it); pruning .baxian-trash keeps the never-emptied trash out of the walk (it only grows, and one unreadable old batch would fail every sweep).
-        const prune = `-name .baxian-trash -prune -o`;
-        const findStaleDirs = `find -H ${subdir} -maxdepth 1 ${prune} -name 'baxian-*' ${keep}`;
-        const findStaleLinks = `find -H ${subdir} ${prune} -path '${subdir}/baxian-*' -type l`;
-        const findStaleFiles = `find -H ${subdir} ${prune} -path '${subdir}/baxian-*/*' -type f ! -name 'SKILL.md'`;
-        const mover = `dest="$0"; for f in "$@"; do ` +
-            `mkdir -p "$dest" || exit 1; ` +
-            `base=$(basename -- "$f"); t="$dest/$base"; n=0; ` +
-            `while [ -e "$t" ] || [ -L "$t" ]; do n=$((n+1)); t="$dest/$base.$n"; done; ` +
-            `mv -- "$f" "$t" || exit 1; ` +
-            `done`;
-        const moveStale = (find) => `${find} -exec sh -c '${mover}' ${batch} {} +`;
-        const inner = `cd ${shellQuote(workdir)} && ` +
-            `mkdir -p ${subdir} && ` +
-            `${moveStale(findStaleDirs)} && ` +
-            `${moveStale(findStaleLinks)} && ` +
-            `${moveStale(findStaleFiles)} && ` +
-            `printf '%s' ${SKILLS_SWEPT}`;
-        const res = await runner.exec(`sh -c ${shellQuote(inner)}`);
-        if (execOutcomeUnknown(res)) {
-            throw new Error(`skill sweep outcome unknown in ${workdir}/${subdir} (exit ${res.exitCode}): ${res.stderr.trim() || res.stdout.trim() || 'no output'}`);
-        }
-        if (res.exitCode !== 0 || !res.stdout.includes(SKILLS_SWEPT)) {
-            throw new Error(`failed to prepare ${subdir} in ${workdir}: ${res.stderr.trim() || `exit ${res.exitCode}, no completion marker`}`);
-        }
-    }
-    async tagSessionSkillsVersion(tmux, agentId, ref) {
-        if (this.skillRegistry.names().length === 0)
-            return;
-        await this.setSessionOptions(tmux, agentId, ref, [
-            ['@baxian-skills-version', this.skillRegistry.contentHash(this.agentSkillScope(agentId))],
-        ]);
-    }
-    async replSkillsStale(tmux, agentId, ref) {
-        if (this.skillRegistry.names().length === 0)
-            return false;
-        const tagged = await tmux.getSessionOptionByRef(ref, agentId, '@baxian-skills-version');
-        return tagged !== this.skillRegistry.contentHash(this.agentSkillScope(agentId));
-    }
-    async excludeInjectedSkills(runner, workdir, subdir) {
-        // cd -P first: tracked/exclude/probe all run against the skills dir's PHYSICAL owning repo, so a symlink pointing back inside a worktree keeps the tracked-content protection while one pointing outside degrades to the plain non-git path.
-        const inner = `cd ${shellQuote(workdir)} && ` +
-            `mkdir -p ${subdir} && cd -P ${subdir} && ` +
-            `if ! git rev-parse --is-inside-work-tree >/dev/null 2>&1; then echo BX_SKILLS_NON_GIT; exit 0; fi; ` +
-            `tracked="$(git ls-files -- 'baxian-*' 2>/dev/null | head -5)"; ` +
-            `if [ -n "$tracked" ]; then printf 'BX_SKILLS_TRACKED %s\\n' "$tracked" | head -1; exit 0; fi; ` +
-            `p="$(git rev-parse --git-path info/exclude)" || { echo BX_SKILLS_EXCLUDE_WRITE_FAILED; exit 0; }; ` +
-            // show-prefix is a literal path but lands in a gitignore pattern: escape fnmatch metacharacters or a dir like skill[dir] never matches its own rule.
-            `pre="$(git rev-parse --show-prefix 2>/dev/null | sed 's/[][\\*?]/\\\\&/g')"; rule="/\${pre}baxian-*"; trashrule="/\${pre}.baxian-trash"; ` +
-            `{ mkdir -p "$(dirname "$p")" && { grep -qxF "$rule" "$p" 2>/dev/null || printf '%s\\n' "$rule" >> "$p"; } ` +
-            `&& { grep -qxF "$trashrule" "$p" 2>/dev/null || printf '%s\\n' "$trashrule" >> "$p"; }; } ` +
-            `|| { echo BX_SKILLS_EXCLUDE_WRITE_FAILED; exit 0; }; ` +
-            `if git check-ignore -q -- 'baxian-__probe__/SKILL.md' ` +
-            `&& git check-ignore -q -- '.baxian-trash/__probe__'; then echo BX_SKILLS_OK; ` +
-            `else echo BX_SKILLS_EXCLUDE_INEFFECTIVE; fi`;
-        const res = await runner.exec(`sh -c ${shellQuote(inner)}`);
-        if (execOutcomeUnknown(res)) {
-            throw new Error(`skill exclusion probe outcome unknown in ${workdir} (exit ${res.exitCode}): ${res.stderr.trim() || res.stdout.trim() || 'no output'}`);
-        }
-        if (res.exitCode !== 0) {
-            throw new Error(`skill exclusion probe failed in ${workdir}: ${res.stderr.trim() || `exit ${res.exitCode}`}`);
-        }
-        const verdict = res.stdout.trim().split('\n').pop() ?? '';
-        if (verdict === 'BX_SKILLS_NON_GIT' || verdict === 'BX_SKILLS_OK')
-            return;
-        if (verdict.startsWith('BX_SKILLS_TRACKED')) {
-            throw new Error(`refusing to inject baxian skills into ${workdir}: project tracks ` +
-                `${verdict.replace('BX_SKILLS_TRACKED ', '')}`);
-        }
-        throw new Error(`cannot make injected skills invisible to Git in ${workdir}: ${verdict || 'no probe output'}`);
-    }
     runtimePinEntries() {
         return [
             ['prefix', 'C-b'],
@@ -849,6 +686,22 @@ export class AgentManager {
             throw new Error(`tmux session ${ref.sessionId} (${agentId}) vanished before its options could be applied`);
         }
     }
+    async taskContextForSession(tmux, agentId, ensure) {
+        if (ensure.freshRuntime) {
+            await this.setSessionOptions(tmux, agentId, ensure.sessionRef, [[TASK_CONTEXT_SESSION_OPTION, '']]);
+            return null;
+        }
+        return tmux.getSessionOptionByRef(ensure.sessionRef, agentId, TASK_CONTEXT_SESSION_OPTION);
+    }
+    async rememberTaskContext(tmux, agentId, ref, taskId) {
+        try {
+            await this.setSessionOptions(tmux, agentId, ref, [[TASK_CONTEXT_SESSION_OPTION, taskId]]);
+        }
+        catch (err) {
+            console.warn(`[AgentManager] prompt for ${agentId}/${taskId} was delivered, but its context marker could not be saved; ` +
+                `the next phase will clear once and resend the full task:`, err);
+        }
+    }
     async resolveClaimedPane(tmux, agentId, expectedPaneId) {
         const snapshot = await tmux.getSessionSnapshot(agentId);
         if (!snapshot)
@@ -863,7 +716,7 @@ export class AgentManager {
         return pane;
     }
     async buildFreshSession(tmux, agent, agentId, workdir, sessionDir = workdir) {
-        return this.runUnderSkillDirLock(this.skillDirLockKey(agent, sessionDir), () => this.buildFreshSessionLocked(tmux, agent, agentId, workdir, sessionDir));
+        return this.buildFreshSessionLocked(tmux, agent, agentId, workdir, sessionDir);
     }
     async buildFreshSessionLocked(tmux, agent, agentId, workdir, sessionDir) {
         let createdSession = false;
@@ -895,7 +748,6 @@ export class AgentManager {
                 timeoutMs: this.bootstrapTimeoutsMs.waitReplReady,
                 scrollback: 0,
             });
-            await this.tagSessionSkillsVersion(tmux, agentId, createdRef);
             return { ok: true, createdSession: true, freshRuntime: true, paneId: pane.paneId, pane, workdir, sessionRef: createdRef };
         }
         catch (err) {
@@ -988,7 +840,7 @@ export class AgentManager {
         for (let attempt = 1; attempt <= this.greetingMaxAttempts; attempt++) {
             const token = createSignalToken();
             try {
-                await this.injectAndAwaitAckSteps(tmux, pane, buildGreetingPrompt(token, agent.runtime), agentId, agent.runtime);
+                await this.injectAndAwaitAckSteps(tmux, pane, buildGreetingPrompt(token), agentId, agent.runtime);
             }
             catch (err) {
                 console.warn(`[bootstrap] greeting inject failed for ${agentId} (attempt ${attempt}):`, err);
@@ -1021,8 +873,8 @@ export class AgentManager {
             return;
         const now = new Date().toISOString();
         const reason = 'Greeting capability check failed: the agent did not echo a valid [bx:greeting] signal ' +
-            'per the baxian-signals skill within the timeout. Its runtime/model may not meet baxian ' +
-            'requirements (skill loading or pane signalling). Fix the runtime, then restart-repl or ' +
+            'from the inline startup instruction within the timeout. Its runtime/model may not meet baxian ' +
+            'pane signalling requirements. Fix the runtime, then restart-repl or ' +
             'retry the agent to re-run the check (Resume will not clear it — capability must be re-proven).';
         let wrote = false;
         await this.agentStore.update(agentId, (fresh) => {
@@ -1519,28 +1371,8 @@ export class AgentManager {
         }
         await this.setSessionOptions(tmux, agentId, sessionRef, [[WORKDIR_SESSION_OPTION, sessionDir]]);
         switch (state.kind) {
-            case 'live-runtime': {
-                let stale;
-                try {
-                    stale = await this.replSkillsStale(tmux, agentId, sessionRef);
-                }
-                catch (err) {
-                    throw new EnsureSessionError({ createdSession: false, agentId }, `skills-version probe failed: ${err instanceof Error ? err.message : String(err)}`);
-                }
-                if (stale) {
-                    return {
-                        ok: true,
-                        createdSession: false,
-                        freshRuntime: false,
-                        skillsStale: true,
-                        paneId,
-                        pane,
-                        workdir,
-                        sessionRef,
-                    };
-                }
+            case 'live-runtime':
                 return { ok: true, createdSession: false, freshRuntime: false, paneId, pane, workdir, sessionRef };
-            }
             case 'startup-dialog':
                 throw new EnsureSessionError({
                     createdSession: false,
@@ -1561,7 +1393,6 @@ export class AgentManager {
                         timeoutMs: this.bootstrapTimeoutsMs.waitReplReady,
                         scrollback: 0,
                     });
-                    await this.tagSessionSkillsVersion(tmux, agentId, sessionRef);
                     return { ok: true, createdSession: false, freshRuntime: true, paneId, pane, workdir, sessionRef };
                 }
                 catch (trustErr) {
@@ -1589,7 +1420,6 @@ export class AgentManager {
                 timeoutMs: this.bootstrapTimeoutsMs.waitReplReady,
                 scrollback: 0,
             });
-            await this.tagSessionSkillsVersion(tmux, agentId, sessionRef);
             return { ok: true, createdSession: false, freshRuntime: true, paneId, pane, workdir, sessionRef };
         }
         catch (relErr) {
@@ -3436,7 +3266,6 @@ export class AgentManager {
         if (!this.deletionGateOpen(agentId, genAtEntry)) {
             throw new Error(`restart-repl: agent ${agentId} is being deleted or was recreated; aborting`);
         }
-        await this.provisionRepoSkills(runner, cfg, workdir);
         await this.setSessionOptions(tmux, agentId, snapshot.ref, [[WORKDIR_SESSION_OPTION, workdir]]);
         const runtime = agentRuntimeKindFor(cfg);
         const relaunch = async () => {
@@ -3449,9 +3278,9 @@ export class AgentManager {
                 timeoutMs: this.bootstrapTimeoutsMs.waitReplReady,
                 scrollback: 0,
             });
-            await this.tagSessionSkillsVersion(tmux, agentId, snapshot.ref);
+            await this.setSessionOptions(tmux, agentId, snapshot.ref, [[TASK_CONTEXT_SESSION_OPTION, '']]);
         };
-        await this.runUnderSkillDirLock(this.skillDirLockKey(cfg, workdir), relaunch);
+        await relaunch();
         await this.agentStore.update(agentId, (state) => {
             if (!state || !this.deletionGateOpen(agentId, genAtEntry))
                 return AGENT_STORE_NOOP;
@@ -3959,9 +3788,8 @@ export class AgentManager {
             phase: 'develop',
             agent: cfg,
             workdir: workdirGuess,
-            skillRegistry: this.skillRegistry,
             signalToken: 'preview-signal-token',
-            platformCli: this.platformCliContextOf(fakeTask),
+            platform: this.platformPromptContextOf(fakeTask),
         });
         return Buffer.byteLength(fullPrompt, 'utf8');
     }
@@ -3972,12 +3800,10 @@ export class AgentManager {
         return this.config.project.find(p => p.id === projectId);
     }
     platformDriverFor(projectId) {
-        if (!this.pluginRegistry)
-            return undefined;
         const project = this.getProjectConfig(projectId);
         if (!project)
             return undefined;
-        return buildProjectDriver(project, this.pluginRegistry, this.platformDriverExec);
+        return buildProjectDriver(project, this.platformDriverExec);
     }
     findAgentTeam(anchorAgentId) {
         for (const project of this.config.project) {
@@ -4484,25 +4310,6 @@ export class AgentManager {
             headSha: completion.approvedHeadSha,
         });
     }
-    async ensurePluginSkillPools(next) {
-        if (!this.pluginRegistry)
-            return;
-        for (const project of next.project) {
-            const tool = resolveProjectTool(project);
-            if (tool === undefined)
-                continue;
-            const plugin = this.pluginRegistry.resolveTool(tool);
-            if (plugin === undefined) {
-                throw new Error(`project '${project.id}': no git-driver plugin provides tool '${tool}' — install it under <home>/plugins/ first`);
-            }
-            if (this.skillRegistry.pluginSkillNames({ pluginTools: [tool] }).length > 0)
-                continue;
-            await this.skillRegistry.scanPluginSkills(tool, join(plugin.pluginPath, 'skills'));
-            if (this.skillRegistry.pluginSkillNames({ pluginTools: [tool] }).length === 0) {
-                throw new Error(`plugin '${plugin.manifest.name}' provides no materializable skills for tool '${tool}'`);
-            }
-        }
-    }
     async guardGitConfigCommit(current, next, scan, commit) {
         return this.withTaskLock(async () => {
             const blockers = await scan(this, current, next);
@@ -5227,51 +5034,16 @@ export class AgentManager {
         const project = this.getProjectConfig(projectId);
         if (!project)
             throw new Error(`project ${projectId} not found while capturing platform binding`);
-        const tool = resolveProjectTool(project);
-        if (tool === undefined)
-            throw new Error(`project ${projectId} has no resolved platform tool`);
         return {
-            mode: 'git',
             repoKey: repoIdentityKey(project.repo),
-            tool,
         };
     }
-    agentGitPreflightContext(projectId) {
-        const project = this.getProjectConfig(projectId);
-        if (!project || !this.pluginRegistry)
-            return undefined;
-        const tool = resolveProjectTool(project);
-        if (tool === undefined)
-            return undefined;
-        const plugin = this.pluginRegistry.resolveTool(tool);
-        if (plugin === undefined)
-            return undefined;
-        const renderCtx = buildDriverRunContext(project.repo, tool);
-        return {
-            tool,
-            minToolVersion: plugin.manifest.minToolVersion,
-            steps: plugin.spec.preflight,
-            agentCommands: plugin.spec.agentCommands,
-            renderCtx,
-            driverFor: (exec) => new GitDriver(plugin, renderCtx, exec),
-        };
-    }
-    platformCliContextOf(task) {
+    platformPromptContextOf(task) {
         this.assertPlatformBinding(task);
         const project = this.getProjectConfig(task.projectId);
         if (!project)
             return undefined;
-        const tool = resolveProjectTool(project);
-        if (tool === undefined)
-            return undefined;
-        const ctx = buildDriverRunContext(project.repo, tool);
-        return {
-            tool,
-            host: ctx.host,
-            repo: ctx.repoPath,
-            repoEncoded: encodeURIComponent(ctx.repoPath),
-            ...(project.gitCli?.notes !== undefined ? { notes: project.gitCli.notes } : {}),
-        };
+        return buildProjectPromptContext(project);
     }
     async ensureGitBaseSnapshot(task, phase) {
         if (phase !== 'develop' && phase !== 'code')
@@ -5340,8 +5112,7 @@ export class AgentManager {
         const { task, driver } = await this.platformTaskAndDriver(taskId);
         if (task.prNumber === undefined)
             throw new Error(`task ${taskId} has no bound PR`);
-        const [row] = await driver.runOp('prView', { prNumber: task.prNumber });
-        return row;
+        return driver.prView(task.prNumber);
     }
     async platformFetchPrHeadSha(taskId) {
         const headSha = String((await this.platformFetchPrView(taskId)).headSha);
@@ -5352,11 +5123,11 @@ export class AgentManager {
     }
     async platformVerifyPrBinding(taskId, prNumber, opts = {}) {
         const { task, driver } = await this.platformTaskAndDriver(taskId);
-        const [row] = await driver.runOp('prView', { prNumber });
+        const row = await driver.prView(prNumber);
         let expectedBase = task.baseBranch;
         if (expectedBase === undefined) {
-            const [project] = await driver.runOp('projectView');
-            if (typeof project?.defaultBranch === 'string')
+            const project = await driver.projectView();
+            if (typeof project.defaultBranch === 'string')
                 expectedBase = project.defaultBranch;
         }
         const check = checkOpenPrBinding(row, { branch: opts.branchOverride ?? task.branch, expectedBase });
@@ -5473,8 +5244,8 @@ export class AgentManager {
             let pr;
             let project;
             try {
-                [pr] = await driver.runOp('prView', { prNumber: intent.prNumber });
-                [project] = await driver.runOp('projectView');
+                pr = await driver.prView(intent.prNumber);
+                project = await driver.projectView();
             }
             catch (err) {
                 if (err instanceof DriverOpError
@@ -5520,7 +5291,7 @@ export class AgentManager {
             task = credentialed;
             intent = credentialed.remoteCleanup;
             try {
-                await driver.runOp('close', { prNumber: intent.prNumber });
+                await driver.closePr(intent.prNumber);
             }
             catch (err) {
                 if (err instanceof DriverOpError
@@ -5582,21 +5353,14 @@ export class AgentManager {
             return;
         let mutationError;
         try {
-            await driver.runOp('deleteBranch', {
-                branch: intent.branch,
-                expectedHeadSha: intent.expectedHeadSha,
-                remoteProjectId: intent.remoteProjectId,
-            });
+            await driver.deleteBranch(intent.remoteProjectId, intent.branch, intent.expectedHeadSha);
         }
         catch (err) {
             mutationError = err;
         }
         let branch;
         try {
-            [branch] = await driver.runOp('branchView', {
-                branch: intent.branch,
-                remoteProjectId: intent.remoteProjectId,
-            });
+            branch = await driver.branchView(intent.remoteProjectId, intent.branch);
         }
         catch (err) {
             const mutation = mutationError === undefined ? '' : `; delete attempt: ${safeDriverErrorText(mutationError)}`;
@@ -5700,7 +5464,7 @@ export class AgentManager {
         if (task.prNumber === undefined)
             throw new Error(`task ${taskId} has no bound PR`);
         const prNumber = task.prNumber;
-        const [row] = await driver.runOp('prView', { prNumber });
+        const row = await driver.prView(prNumber);
         const binding = checkOpenPrBinding(row, { branch: task.branch, expectedBase: task.baseBranch });
         if (!binding.ok)
             throw new Error(`merge blocked: binding ${binding.reason}`);
@@ -5747,13 +5511,13 @@ export class AgentManager {
             throw new Error(`merge blocked: task left its merge gate (status=${fresh?.status ?? 'gone'})`);
         }
         try {
-            await driver.runOp('merge', { prNumber, expectedHeadSha: opts.expectedHeadSha });
+            await driver.mergePr(prNumber, opts.expectedHeadSha);
         }
         catch (err) {
             if (err instanceof DriverOpError && err.info.errorClass === 'MERGE_BLOCKED') {
                 let mergeStatus;
                 try {
-                    const [fresh] = await driver.runOp('prView', { prNumber });
+                    const fresh = await driver.prView(prNumber);
                     if (typeof fresh?.detailedMergeStatus === 'string')
                         mergeStatus = fresh.detailedMergeStatus;
                 }
@@ -5774,9 +5538,7 @@ export class AgentManager {
     taskBelongsToPlatformEntry(task, entryBinding) {
         const binding = task.platformBinding;
         return binding !== undefined
-            && binding.mode === entryBinding.mode
-            && binding.repoKey === entryBinding.repoKey
-            && binding.tool === entryBinding.tool;
+            && binding.repoKey === entryBinding.repoKey;
     }
     async listTasksForPlatformEntry(projectId) {
         const project = this.getProjectConfig(projectId);
@@ -5784,9 +5546,7 @@ export class AgentManager {
             return [];
         const key = repoIdentityKey(project.repo);
         const entryBinding = {
-            mode: 'git',
             repoKey: key,
-            tool: resolveProjectTool(project) ?? '',
         };
         const ids = new Set(this.config.project.filter(p => repoIdentityKey(p.repo) === key).map(p => p.id));
         const tasks = await this.taskStore.listStrict();
@@ -5973,8 +5733,7 @@ export class AgentManager {
         if (this.repoStoreFactory) {
             return this.repoStoreFactory(runner, project.repo, agent.mode, host, this.repoCache, agent.id, agent.workdir);
         }
-        const cloneViaGh = resolveProjectTool(project) === 'gh';
-        return new RepoStore(runner, project.repo, agent.mode, host, this.repoCache, agent.id, agent.workdir, cloneViaGh);
+        return new RepoStore(runner, project.repo, agent.mode, host, this.repoCache, agent.id, agent.workdir);
     }
     async ensureWorkdir(agent, project, runner) {
         const repoStore = this.createRepoStore(agent, project, runner);
@@ -6444,6 +6203,9 @@ export class AgentManager {
             await tmux.clearComposerDraft(pane);
             await waitReady();
             await assertSessionUnchanged();
+            if (command === '/clear') {
+                await this.setSessionOptions(tmux, agentId, pane.session, [[TASK_CONTEXT_SESSION_OPTION, '']]);
+            }
             await tmux.sendKeysLiteral(pane, command);
             await tmux.sendEnter(pane);
             guardHandedOff = true;
@@ -6544,7 +6306,7 @@ export class AgentManager {
             `${phase} queued for redispatch when idle (${(err.message.split('\n')[0])})`);
         return new EnsureSessionError({ createdSession, agentId, handled: true, busyPending: true }, `QA REPL busy; ${phase} dispatch for task ${taskId} queued for redispatch when idle`);
     }
-    async clearRuntimeForDispatchBoundary(tmux, pane, agentId, runtime, revalidate) {
+    async clearRuntimeForDispatchBoundary(tmux, pane, agentId, runtime, sessionRef, revalidate) {
         await this.acquireCompactGuard(agentId);
         try {
             await this.waitForReplPromptReady(tmux, pane, runtime, this.cleanComposerWaitMs, { stableIdle: true });
@@ -6554,6 +6316,7 @@ export class AgentManager {
                 timeoutMs: this.dispatchSettleTimeoutMs,
             });
             const baselineTitle = await tmux.readPaneTitle(pane);
+            await this.setSessionOptions(tmux, agentId, sessionRef, [[TASK_CONTEXT_SESSION_OPTION, '']]);
             await tmux.sendKeysLiteral(pane, '/clear');
             await tmux.sendEnter(pane);
             await tmux.waitSubmitAck(pane, baseline, runtime, {
@@ -6952,6 +6715,7 @@ export class AgentManager {
         if (!lockState || lockState.taskId !== taskId || lockState.lockToken !== lockToken)
             return false;
         await assertOwner();
+        const reuseTaskContext = (await this.taskContextForSession(tmux, agentId, ensure)) === taskId;
         try {
             await this.waitForReplPromptReady(tmux, pane, agent.runtime, this.cleanComposerWaitMs, { stableIdle: true });
         }
@@ -6978,10 +6742,8 @@ export class AgentManager {
                     await this.clearBranchLocalCleaned(taskId);
             }
             await assertOwner();
-            if (!ensure.freshRuntime) {
-                await this.clearRuntimeForDispatchBoundary(tmux, pane, agentId, agent.runtime, assertOwner);
-                if (ensure.skillsStale)
-                    await this.tagSessionSkillsVersion(tmux, agentId, ensure.sessionRef);
+            if (!ensure.freshRuntime && !reuseTaskContext) {
+                await this.clearRuntimeForDispatchBoundary(tmux, pane, agentId, agent.runtime, ensure.sessionRef, assertOwner);
             }
         }
         catch (err) {
@@ -7039,14 +6801,14 @@ export class AgentManager {
         try {
             const imagePaths = await this.imagePathsForDispatch(runner, task, phase);
             const taskForPrompt = await this.ensureGitBaseSnapshot(task, phase);
-            const platformCli = this.platformCliContextOf(taskForPrompt);
+            const platform = this.platformPromptContextOf(taskForPrompt);
             prompt = buildPromptInline({
                 task: taskForPrompt,
                 phase,
                 agent,
                 workdir: dispatchWorkdir,
-                skillRegistry: this.skillRegistry,
-                ...(platformCli ? { platformCli } : {}),
+                includeTaskContext: ensure.freshRuntime || !reuseTaskContext,
+                ...(platform ? { platform } : {}),
                 ...(promptSignalToken ? { signalToken: promptSignalToken } : {}),
                 ...(imagePaths.length ? { imagePaths } : {}),
             });
@@ -7056,9 +6818,6 @@ export class AgentManager {
             if (err instanceof PromptSizeError) {
                 throw new DispatchTerminalError('prompt_too_large', err.message);
             }
-            if (err instanceof RequiredSkillsMissingError) {
-                throw new DispatchTerminalError('required_skills_missing', err.message);
-            }
             throw err;
         }
         const taskFresh = await this.taskStore.get(taskId);
@@ -7159,6 +6918,9 @@ export class AgentManager {
                 console.warn(`[AgentManager] startSession[${phase}]: injection fenced off (pass superseded) for task ${taskId}`);
                 return false;
             }
+            if (!reuseTaskContext) {
+                await this.rememberTaskContext(tmux, agentId, ensure.sessionRef, taskId);
+            }
             if (opts.dispatchPassToken !== undefined) {
                 this.clearPendingDispatchRetryIfMatches(taskId, { agentId, signalToken: opts.dispatchPassToken });
             }
@@ -7522,6 +7284,7 @@ export class AgentManager {
             return false;
         }
         await this.assertTaskLockOwner(agentId, taskId, lockToken);
+        const reuseTaskContext = (await this.taskContextForSession(tmux, agentId, ensure)) === taskId;
         const verifiedWorkdir = stateAfterEnsure.workdir;
         if (!verifiedWorkdir
             || verifiedWorkdir !== ensure.workdir
@@ -7565,14 +7328,14 @@ export class AgentManager {
         try {
             const imagePaths = await this.imagePathsForDispatch(runner, task, phase);
             const taskForPrompt = await this.ensureGitBaseSnapshot(task, phase);
-            const platformCli = this.platformCliContextOf(taskForPrompt);
+            const platform = this.platformPromptContextOf(taskForPrompt);
             prompt = buildPromptInline({
                 task: taskForPrompt,
                 phase,
                 agent,
                 workdir: verifiedWorkdir,
-                skillRegistry: this.skillRegistry,
-                ...(platformCli ? { platformCli } : {}),
+                includeTaskContext: ensure.freshRuntime || !reuseTaskContext,
+                ...(platform ? { platform } : {}),
                 ...(signalToken ? { signalToken } : {}),
                 ...(imagePaths.length ? { imagePaths } : {}),
             });
@@ -7581,9 +7344,6 @@ export class AgentManager {
             if (err instanceof PromptSizeError) {
                 throw new DispatchTerminalError('prompt_too_large', err.message);
             }
-            if (err instanceof RequiredSkillsMissingError) {
-                throw new DispatchTerminalError('required_skills_missing', err.message);
-            }
             throw err;
         }
         const taskFresh = await this.taskStore.get(taskId);
@@ -7641,8 +7401,8 @@ export class AgentManager {
             return false;
         }
         const guardBeforeInject = opts.guardBeforeInject ?? (phase === 'post-approve' ? postApprovePassStillLive : undefined);
-        if (!ensure.freshRuntime && ensure.skillsStale) {
-            const revalidateSkillRefresh = async () => {
+        if (!ensure.freshRuntime && !reuseTaskContext) {
+            const revalidateContextReset = async () => {
                 const [currentTask, currentAgent] = await Promise.all([
                     this.taskStore.get(taskId),
                     this.agentStore.get(agentId),
@@ -7657,15 +7417,14 @@ export class AgentManager {
                     || !bindingStillDispatchable
                     || currentAgent?.lockToken !== lockToken
                     || currentAgent.workdir !== verifiedWorkdir) {
-                    throw new Error(`Task or agent ownership changed while refreshing skills for ${phase} dispatch`);
+                    throw new Error(`Task or agent ownership changed while resetting context for ${phase} dispatch`);
                 }
                 await this.assertTaskLockOwner(agentId, taskId, lockToken);
                 if (guardBeforeInject && !(await guardBeforeInject())) {
-                    throw new Error(`Task generation changed while refreshing skills for ${phase} dispatch`);
+                    throw new Error(`Task generation changed while resetting context for ${phase} dispatch`);
                 }
             };
-            await this.clearRuntimeForDispatchBoundary(tmux, pane, agentId, agent.runtime, revalidateSkillRefresh);
-            await this.tagSessionSkillsVersion(tmux, agentId, ensure.sessionRef);
+            await this.clearRuntimeForDispatchBoundary(tmux, pane, agentId, agent.runtime, ensure.sessionRef, revalidateContextReset);
         }
         if (opts.armBeforeInject && !(await opts.armBeforeInject())) {
             return false;
@@ -7708,6 +7467,9 @@ export class AgentManager {
             console.warn(`[AgentManager] continueSession[${phase}]: pre-paste guard rejected the inject for task ${taskId}; skipping`);
             return false;
         }
+        if (!reuseTaskContext) {
+            await this.rememberTaskContext(tmux, agentId, ensure.sessionRef, taskId);
+        }
         return true;
     }
     async rollbackUndeliveredBootstrap(state) {
@@ -8256,14 +8018,11 @@ export class AgentManager {
             previewBytes = this.previewPromptBytesForTaskInput(projectId, input);
         }
         catch (err) {
-            if (err instanceof RequiredSkillsMissingError) {
-                throw new ApiError(500, err.message);
-            }
             throw new ApiError(400, err instanceof Error ? err.message : String(err));
         }
         if (previewBytes > MAX_PROMPT_BYTES_ROUTE_LIMIT) {
             throw new ApiError(400, `estimated prompt size ${previewBytes} bytes exceeds ${MAX_PROMPT_BYTES_ROUTE_LIMIT} limit; ` +
-                `reduce task description or remove some skills from AGENT_PHASES[develop]`);
+                `reduce the task description or platform workflow instructions`);
         }
     }
     gitReviewClaimMatches(task, expected) {
@@ -9669,7 +9428,7 @@ export class AgentManager {
         let opposite = false;
         for (const scan of scans) {
             for (const row of scan.rows) {
-                if (row.system === true || versionTimeOf(row) === undefined)
+                if (versionTimeOf(row) === undefined)
                     continue;
                 for (const marker of rowTokens(row)) {
                     if (dead.has(marker.token))
@@ -9694,9 +9453,7 @@ export class AgentManager {
             return 'unknown';
         if (deadTokens(scans).has(entry.data.token))
             return 'dead';
-        if (scans.some(scan => scan.rows.some(row => row.system !== true
-            && versionTimeOf(row) !== undefined
-            && row.bodyDigest === expectedDigest)))
+        if (scans.some(scan => scan.rows.some(row => versionTimeOf(row) !== undefined && row.bodyDigest === expectedDigest)))
             return 'present';
         return 'absent';
     }
@@ -9753,10 +9510,7 @@ export class AgentManager {
         entry = claimedEntry;
         let writeFailure;
         try {
-            await driver.runOp('comment', {
-                prNumber: entry.data.prNumber,
-                body: this.codeVerdictCommentBody(entry),
-            });
+            await driver.postComment(entry.data.prNumber, this.codeVerdictCommentBody(entry));
         }
         catch (error) {
             writeFailure = { error };
@@ -9956,10 +9710,7 @@ export class AgentManager {
             entry = claimedEntry;
             let writeFailure;
             try {
-                await driver.runOp('comment', {
-                    prNumber: entry.data.prNumber,
-                    body: this.specVerdictCommentBody(entry),
-                });
+                await driver.postComment(entry.data.prNumber, this.specVerdictCommentBody(entry));
             }
             catch (error) {
                 writeFailure = { error };