@fitlab-ai/agent-infra 0.9.11 → 0.9.13

package/dist/lib/task/commands/status.js

@@ -11,6 +11,9 @@ import { getOpenWorkflowWarnings, formatWorkflowWarningSummary } from '../workfl
 import { parseActivityLog, pairEntries, startedBackedRows } from '../activity-log.js';
 import { readRun } from '../orchestration.js';
 import { statusCard } from '../../server/display.js';
+import { invalidationBlocks, parseInvalidationDocument } from '../invalidation.js';
+import { parseReworkIntentDocument } from '../rework-intent.js';
+import { buildLifecycleFacts, recommendNext } from '../capabilities.js';
 const USAGE = `Usage: ai task status [--task <ref> | -t <ref>]
 
 Prints an aggregated "health check" view for a task: header, metadata,
@@ -317,6 +320,12 @@ function renderStatus(model) {
     else {
         lines.push(...renderPairs(model.artifacts.groups.map((group) => [group.stage, group.files.join(', ')])));
     }
+    lines.push('', 'Invalidation', ...renderPairs([
+        ['status', model.invalidation?.status ?? 'unknown'],
+        ['processed', `${model.invalidation?.processed ?? 0}/${model.invalidation?.total ?? 0}`],
+        ['pending_intents', String(model.invalidation?.pendingIntents ?? 0)]
+    ]));
+    lines.push('', 'Recommendation', ...renderPairs([['action', model.recommendation ?? DASH]]));
     lines.push('', 'Orchestration', ...renderPairs([
         ['status', model.orchestration.status],
         ['run_id', model.orchestration.runId],
@@ -361,6 +370,10 @@ function renderStatus(model) {
     return lines;
 }
 function modelTone(model) {
+    if (model.invalidation?.status === 'invalid')
+        return 'danger';
+    if (model.invalidation?.status === 'pending' || model.invalidation?.status === 'in-progress')
+        return 'warning';
     if (model.orchestration.status === 'paused')
         return 'warning';
     if (model.orchestration.status === 'running')
@@ -382,6 +395,23 @@ function buildFromResolved(input) {
     const run = input.run ?? makeRunner(input.repoRoot);
     const artifacts = enumerateArtifacts(input.taskDir);
     const workflow = collectWorkflow(content, input.now);
+    const invalidation = parseInvalidationDocument(content);
+    const rework = parseReworkIntentDocument(content);
+    const pendingIntents = rework.ok ? rework.intents.filter((intent) => intent.status === 'pending').length : 0;
+    const invalidationInfo = !invalidation.ok
+        ? { status: 'invalid', processed: 0, total: 0, pendingIntents }
+        : {
+            status: invalidation.present
+                ? invalidationBlocks(invalidation.document)
+                    ? invalidation.document.operations.some((operation) => operation.status === 'in-progress') ? 'in-progress' : 'pending'
+                    : 'completed'
+                : 'none',
+            processed: invalidation.document.operations.reduce((sum, operation) => sum + operation.processed, 0),
+            total: invalidation.document.operations.reduce((sum, operation) => sum + operation.total, 0),
+            pendingIntents
+        };
+    const facts = buildLifecycleFacts(input.taskDir, content, fm.status ?? 'active');
+    const recommendation = facts.ok ? (recommendNext(facts.facts).action ?? DASH) : DASH;
     return {
         taskId: input.taskId,
         shortId: input.shortId ?? loadShortIdByTaskId(input.repoRoot).get(input.taskId) ?? DASH,
@@ -392,6 +422,8 @@ function buildFromResolved(input) {
         workflow,
         runtime: collectRuntime(input.taskDir, workflow, run),
         orchestration: collectOrchestration(input.taskDir),
+        invalidation: invalidationInfo,
+        recommendation,
         git: collectGit(fm.branch ?? '', run)
     };
 }

package/dist/lib/task/commit-intent.js

@@ -0,0 +1,100 @@
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+function intentRoot(repoRoot) {
+    return path.join(repoRoot, '.agents', 'workspace', '.task-commit-intents');
+}
+function intentPath(repoRoot, taskId) {
+    return path.join(intentRoot(repoRoot), `${taskId}.json`);
+}
+function checkpointIntentDigest(identity) {
+    return createHash('sha256').update(JSON.stringify({
+        taskId: identity.taskId,
+        branch: identity.branch,
+        mode: identity.mode,
+        expectedHead: identity.expectedHead,
+        expectedTree: identity.expectedTree,
+        paths: [...identity.paths],
+        message: identity.message,
+        round: identity.round
+    })).digest('hex');
+}
+function isIntent(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const intent = value;
+    return intent.version === 1
+        && typeof intent.taskId === 'string' && intent.taskId.length > 0
+        && typeof intent.branch === 'string' && intent.branch.length > 0
+        && intent.mode === 'local'
+        && typeof intent.expectedHead === 'string' && /^[a-f0-9]{40,64}$/.test(intent.expectedHead)
+        && typeof intent.expectedTree === 'string' && /^[a-f0-9]{40,64}$/.test(intent.expectedTree)
+        && Array.isArray(intent.paths) && intent.paths.every((item) => typeof item === 'string' && item.length > 0)
+        && typeof intent.message === 'string' && intent.message.length > 0
+        && Number.isSafeInteger(intent.round) && Number(intent.round) > 0
+        && typeof intent.digest === 'string' && /^[a-f0-9]{64}$/.test(intent.digest)
+        && ['prepared', 'committed', 'synced'].includes(String(intent.state))
+        && (intent.committedHead === null || (typeof intent.committedHead === 'string' && /^[a-f0-9]{40,64}$/.test(intent.committedHead)))
+        && typeof intent.createdAt === 'string' && intent.createdAt.length > 0
+        && typeof intent.updatedAt === 'string' && intent.updatedAt.length > 0
+        && intent.digest === checkpointIntentDigest(intent);
+}
+function readCheckpointIntent(repoRoot, taskId) {
+    const target = intentPath(repoRoot, taskId);
+    if (!fs.existsSync(target))
+        return null;
+    const value = JSON.parse(fs.readFileSync(target, 'utf8'));
+    if (!isIntent(value))
+        throw new Error('COMMIT_INTENT_INVALID: checkpoint intent schema is invalid');
+    return value;
+}
+function writeCheckpointIntent(repoRoot, value) {
+    if (!isIntent(value))
+        throw new Error('COMMIT_INTENT_INVALID: checkpoint intent schema is invalid');
+    const directory = intentRoot(repoRoot);
+    fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+    const target = intentPath(repoRoot, value.taskId);
+    const temporary = `${target}.${process.pid}.${Date.now()}.tmp`;
+    fs.writeFileSync(temporary, `${JSON.stringify(value)}\n`, { encoding: 'utf8', mode: 0o600, flag: 'wx' });
+    try {
+        fs.renameSync(temporary, target);
+    }
+    catch (error) {
+        try {
+            fs.unlinkSync(temporary);
+        }
+        catch { /* preserve primary error */ }
+        throw error;
+    }
+}
+function updateCheckpointIntent(value, patch) {
+    const next = { ...value, ...patch };
+    if (next.state === 'prepared' && next.committedHead !== null)
+        throw new Error('COMMIT_INTENT_INVALID: prepared intent cannot have a committed head');
+    if (next.state !== 'prepared' && !next.committedHead)
+        throw new Error('COMMIT_INTENT_INVALID: committed intent requires a committed head');
+    return next;
+}
+function removeCheckpointIntent(repoRoot, taskId) {
+    const target = intentPath(repoRoot, taskId);
+    try {
+        fs.unlinkSync(target);
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+}
+function sameCheckpointIntent(left, right) {
+    return left.digest === checkpointIntentDigest(right)
+        && left.taskId === right.taskId
+        && left.branch === right.branch
+        && left.mode === right.mode
+        && left.expectedHead === right.expectedHead
+        && left.expectedTree === right.expectedTree
+        && left.message === right.message
+        && left.round === right.round
+        && JSON.stringify(left.paths) === JSON.stringify(right.paths);
+}
+export { checkpointIntentDigest, intentPath, intentRoot, isIntent, readCheckpointIntent, removeCheckpointIntent, sameCheckpointIntent, updateCheckpointIntent, writeCheckpointIntent };
+//# sourceMappingURL=commit-intent.js.map

package/dist/lib/task/commit-operation.js

@@ -8,7 +8,7 @@ import { mergeOperationWarnings } from './operation-outcome.js';
 import { TaskExecutionLockError, withRepositoryMutationLock, withTaskExecutionLock } from './task-execution-lock.js';
 import { appendActivityEntry, locateActivityLog } from './activity-log.js';
 import { captureTaskWriteMetadata, writeTask } from './write.js';
-import { commitOrchestrationStageCompletion, planOrchestrationStageCompletion } from './orchestration.js';
+import { checkpointIntentDigest, readCheckpointIntent, removeCheckpointIntent, sameCheckpointIntent, updateCheckpointIntent, writeCheckpointIntent } from './commit-intent.js';
 const HEAD_REF = /^refs\/heads\/(.+)$/;
 function isCommitExecutionMode(value) {
     return value === 'direct' || value === 'orchestrated';
@@ -20,6 +20,13 @@ function gitText(repoRoot, args) {
         stdio: ['ignore', 'pipe', 'pipe']
     }).trim();
 }
+function effectiveDelivery(input) {
+    if (input.delivery)
+        return input.delivery;
+    if (input.push)
+        return { mode: 'push', remote: input.push.remote, refs: input.push.refs };
+    return null;
+}
 function canonicalRepositoryRoot(cwd) {
     return gitText(cwd, ['rev-parse', '--show-toplevel']);
 }
@@ -86,8 +93,9 @@ function validateCommon(input, branch) {
         return { code: 'GIT_HEAD_EXPECTATION_REQUIRED', message: 'A valid expected HEAD is required' };
     if (!/^[a-f0-9]{40,64}$/.test(input.expectedTree))
         return { code: 'GIT_TREE_EXPECTATION_REQUIRED', message: 'A valid expected tree is required' };
-    if (!input.push)
-        return { code: 'GIT_PUSH_INPUT_INVALID', message: 'Commit delivery requires a push policy' };
+    const delivery = effectiveDelivery(input);
+    if (!delivery)
+        return { code: 'GIT_PUSH_INPUT_INVALID', message: 'Commit delivery requires a delivery policy' };
     if (input.paths.some((candidate) => !candidate || candidate.startsWith('/') || candidate.split(/[\\/]/).includes('..'))) {
         return { code: 'GIT_COMMIT_INPUT_INVALID', message: 'Commit paths must stay inside the repository' };
     }
@@ -96,38 +104,16 @@ function validateCommon(input, branch) {
     }
     if (branch !== null && branch === '')
         return { code: 'GIT_BRANCH_INVALID', message: 'A named branch is required' };
-    if (!input.push.remote || input.push.refs.length !== 1)
-        return { code: 'GIT_PUSH_INPUT_INVALID', message: 'Push requires one remote and one ref' };
-    const ref = input.push.refs[0] ?? '';
-    if (!HEAD_REF.test(ref) || HEAD_REF.exec(ref)?.[1] !== branch) {
-        return { code: 'GIT_PUSH_INPUT_INVALID', message: 'Push ref must be the current full heads ref' };
+    if (delivery.mode === 'push') {
+        if (!delivery.remote || delivery.refs.length !== 1)
+            return { code: 'GIT_PUSH_INPUT_INVALID', message: 'Push requires one remote and one ref' };
+        const ref = delivery.refs[0] ?? '';
+        if (!HEAD_REF.test(ref) || HEAD_REF.exec(ref)?.[1] !== branch) {
+            return { code: 'GIT_PUSH_INPUT_INVALID', message: 'Push ref must be the current full heads ref' };
+        }
     }
     return null;
 }
-function validateOrchestrated(input, task) {
-    if (!input.agent)
-        return { error: { code: 'ORCHESTRATION_PROVENANCE_MISMATCH', message: 'orchestrated commit requires an agent' } };
-    const planned = planOrchestrationStageCompletion(task.taskId, {
-        stage: 'commit',
-        round: 1,
-        artifact: 'commit',
-        role: 'executor',
-        agent: input.agent
-    }, { repoRoot: task.repoRoot });
-    const run = planned.result.run;
-    if (!planned.plan
-        || !run
-        || run.status !== 'running'
-        || !run.commitAuthorization.issuedAt
-        || run.commitAuthorization.consumedAt)
-        return {
-            error: {
-                code: planned.result.error?.code ?? 'ORCHESTRATION_PROVENANCE_MISMATCH',
-                message: planned.result.error?.message ?? 'orchestrated commit requires one matching activated commit delegation'
-            }
-        };
-    return { plan: planned.plan };
-}
 function syncTaskCommit(input, task, committedHead) {
     let content;
     try {
@@ -137,7 +123,18 @@ function syncTaskCommit(input, task, committedHead) {
             return warning('TASK_STATUS_SYNC_FAILED', 'task has no unique Activity Log section', true, 'task', task.taskId, 'ACTION_REQUIRED');
         const metadata = captureTaskWriteMetadata();
         const commitNote = gitText(task.repoRoot, ['show', '-s', '--format=%h %s', committedHead]);
-        const alreadyLogged = activity.entries.some((entry) => entry.step === 'Commit' && entry.note === commitNote);
+        let matchingCommitIndex = -1;
+        for (let index = activity.entries.length - 1; index >= 0; index -= 1) {
+            const entry = activity.entries[index];
+            if (entry.step === 'Commit' && entry.note === commitNote) {
+                matchingCommitIndex = index;
+                break;
+            }
+        }
+        const reviewedAfterCommit = matchingCommitIndex >= 0 && activity.entries
+            .slice(matchingCommitIndex + 1)
+            .some((entry) => /^Review Code \(Round \d+\)$/.test(entry.step));
+        const alreadyLogged = matchingCommitIndex >= 0 && !reviewedAfterCommit;
         const mutations = [];
         if (!alreadyLogged)
             mutations.push({
@@ -146,7 +143,10 @@ function syncTaskCommit(input, task, committedHead) {
                 heading: activity.heading,
                 body: appendActivityEntry(activity, { time: metadata.timestamp, step: 'Commit', agent: input.agent, note: commitNote })
             });
-        const frontmatter = { assigned_to: input.agent };
+        const frontmatter = {
+            assigned_to: input.agent,
+            checkpoint_commit: committedHead
+        };
         mutations.push({ kind: 'frontmatter', set: frontmatter });
         if (mutations.length === 0)
             return null;
@@ -163,10 +163,44 @@ function syncTaskCommit(input, task, committedHead) {
         return warning('TASK_STATUS_SYNC_FAILED', error instanceof Error ? error.message : String(error), true, 'task', task.taskId, 'ACTION_REQUIRED');
     }
 }
+function checkpointChildMatches(task, intent, head) {
+    try {
+        const parent = gitText(task.repoRoot, ['rev-parse', `${head}^`]);
+        const tree = gitText(task.repoRoot, ['rev-parse', `${head}^{tree}`]);
+        const message = gitText(task.repoRoot, ['show', '-s', '--format=%s', head]);
+        const changed = gitText(task.repoRoot, ['diff-tree', '--no-commit-id', '--name-only', '-r', head]).split('\n').filter(Boolean).sort();
+        return parent === intent.expectedHead
+            && tree === intent.expectedTree
+            && message === intent.message
+            && JSON.stringify(changed) === JSON.stringify([...intent.paths].sort());
+    }
+    catch {
+        return false;
+    }
+}
+function checkpointIdentity(input, task, delivery) {
+    if (delivery.mode !== 'local')
+        throw new Error('checkpoint identity requires local delivery');
+    return {
+        taskId: task.taskId,
+        branch: task.branch,
+        mode: 'local',
+        expectedHead: input.expectedHead,
+        expectedTree: input.expectedTree,
+        paths: [...input.paths],
+        message: input.message,
+        round: input.round ?? 1
+    };
+}
+function checkpointTimestamp() {
+    return new Date().toISOString();
+}
 function executeUnlocked(input, task, mode) {
     const inspected = inspectGitWorkflow(input.cwd);
     if (!inspected.snapshot)
         return failure(input, mode, task?.taskId ?? null, 'GIT_INSPECT_FAILED', 'Unable to inspect Git repository');
+    if (mode === 'orchestrated')
+        return failure(input, mode, task?.taskId ?? null, 'ORCHESTRATED_COMMIT_REMOVED', 'Orchestrated commit is no longer a lifecycle stage; use local checkpoint delivery from code-task', 'blocked', inspected.snapshot);
     const branch = inspected.snapshot.branch;
     const commonError = validateCommon(input, branch);
     if (commonError)
@@ -177,60 +211,131 @@ function executeUnlocked(input, task, mode) {
         return failure(input, mode, task.taskId, 'GIT_BRANCH_MISMATCH', `Task branch '${task.branch}' does not match current branch '${branch}'`, 'blocked', inspected.snapshot);
     if (task && !input.agent)
         return failure(input, mode, task.taskId, 'COMMIT_AGENT_REQUIRED', 'task-bound commit requires an agent', 'blocked', inspected.snapshot);
-    const orchestrationValidation = mode === 'orchestrated'
-        ? (task
-            ? validateOrchestrated(input, task)
-            : { error: { code: 'ORCHESTRATION_TASK_REQUIRED', message: 'orchestrated commit requires a task context' } })
-        : null;
-    if (orchestrationValidation && 'error' in orchestrationValidation) {
-        const error = orchestrationValidation.error;
-        return failure(input, mode, task?.taskId ?? null, error.code, error.message, 'blocked', inspected.snapshot);
-    }
-    const orchestrationCompletion = orchestrationValidation && 'plan' in orchestrationValidation
-        ? orchestrationValidation.plan
-        : null;
-    const committed = input.paths.length === 0
+    const delivery = effectiveDelivery(input);
+    if (delivery.mode === 'local' && !task)
+        return failure(input, mode, null, 'CHECKPOINT_TASK_REQUIRED', 'local checkpoint delivery requires a task context', 'blocked', inspected.snapshot);
+    let pendingIntent = null;
+    let checkpointCommittedHead = null;
+    const committed = delivery.mode === 'local'
         ? (() => {
-            if (inspected.snapshot.worktree.length > 0 || inspected.snapshot.staged.length > 0)
+            const identity = checkpointIdentity(input, task, delivery);
+            try {
+                pendingIntent = readCheckpointIntent(task.repoRoot, task.taskId);
+            }
+            catch (error) {
                 return {
-                    status: 'failed',
-                    changed: false,
-                    snapshot: inspected.snapshot,
-                    operations: [],
-                    error: { code: 'GIT_COMMIT_INPUT_INVALID', message: 'Push-only retry requires a clean working tree' }
+                    status: 'failed', changed: false, snapshot: inspected.snapshot, operations: [],
+                    error: { code: 'COMMIT_INTENT_INVALID', message: error instanceof Error ? error.message : String(error) }
                 };
-            if (inspected.snapshot.head !== input.expectedHead)
+            }
+            if (pendingIntent && !sameCheckpointIntent(pendingIntent, identity))
                 return {
-                    status: 'failed',
-                    changed: false,
-                    snapshot: inspected.snapshot,
-                    operations: [],
-                    error: { code: 'GIT_HEAD_MISMATCH', message: `Expected HEAD ${input.expectedHead}, received ${inspected.snapshot.head}` }
+                    status: 'failed', changed: false, snapshot: inspected.snapshot, operations: [],
+                    error: { code: 'COMMIT_INTENT_CONFLICT', message: 'A different checkpoint intent is still pending for this task' }
+                };
+            if (!pendingIntent) {
+                const timestamp = checkpointTimestamp();
+                pendingIntent = {
+                    version: 1, ...identity, digest: checkpointIntentDigest(identity), state: 'prepared',
+                    committedHead: null, createdAt: timestamp, updatedAt: timestamp
+                };
+                try {
+                    writeCheckpointIntent(task.repoRoot, pendingIntent);
+                }
+                catch (error) {
+                    return {
+                        status: 'failed', changed: false, snapshot: inspected.snapshot, operations: [],
+                        error: { code: 'COMMIT_INTENT_WRITE_FAILED', message: error instanceof Error ? error.message : String(error) }
+                    };
+                }
+            }
+            if (pendingIntent.state !== 'prepared') {
+                checkpointCommittedHead = pendingIntent.committedHead;
+                return {
+                    status: 'no-op', changed: false, snapshot: inspected.snapshot,
+                    operations: [{ name: 'commit', status: 'no-op' }], error: null
+                };
+            }
+            if (inspected.snapshot.head !== identity.expectedHead && !checkpointChildMatches(task, pendingIntent, inspected.snapshot.head))
+                return {
+                    status: 'failed', changed: false, snapshot: inspected.snapshot, operations: [],
+                    error: { code: 'COMMIT_INTENT_HEAD_CONFLICT', message: 'Current HEAD does not match the pending checkpoint intent' }
+                };
+            if (inspected.snapshot.head !== identity.expectedHead) {
+                checkpointCommittedHead = inspected.snapshot.head;
+                pendingIntent = updateCheckpointIntent(pendingIntent, {
+                    state: 'committed', committedHead: checkpointCommittedHead, updatedAt: checkpointTimestamp()
+                });
+                writeCheckpointIntent(task.repoRoot, pendingIntent);
+                return {
+                    status: 'no-op', changed: false, snapshot: inspected.snapshot,
+                    operations: [{ name: 'commit', status: 'no-op' }], error: null
                 };
-            const currentTree = gitText(input.cwd, ['rev-parse', 'HEAD^{tree}']);
-            if (currentTree !== input.expectedTree)
+            }
+            if (input.paths.length === 0)
+                return {
+                    status: 'failed', changed: false, snapshot: inspected.snapshot, operations: [],
+                    error: { code: 'GIT_COMMIT_INPUT_INVALID', message: 'Local checkpoint requires explicit paths' }
+                };
+            const created = commitExplicitPaths({
+                cwd: input.cwd, paths: input.paths, message: input.message,
+                expectedHead: identity.expectedHead, expectedTree: identity.expectedTree
+            });
+            if (created.status === 'applied' && created.snapshot?.head) {
+                checkpointCommittedHead = created.snapshot.head;
+                pendingIntent = updateCheckpointIntent(pendingIntent, {
+                    state: 'committed', committedHead: checkpointCommittedHead, updatedAt: checkpointTimestamp()
+                });
+                writeCheckpointIntent(task.repoRoot, pendingIntent);
+            }
+            else if (created.status === 'no-op') {
+                removeCheckpointIntent(task.repoRoot, task.taskId);
+                pendingIntent = null;
+            }
+            return created;
+        })()
+        : input.paths.length === 0
+            ? (() => {
+                if (inspected.snapshot.worktree.length > 0 || inspected.snapshot.staged.length > 0)
+                    return {
+                        status: 'failed',
+                        changed: false,
+                        snapshot: inspected.snapshot,
+                        operations: [],
+                        error: { code: 'GIT_COMMIT_INPUT_INVALID', message: 'Push-only retry requires a clean working tree' }
+                    };
+                if (inspected.snapshot.head !== input.expectedHead)
+                    return {
+                        status: 'failed',
+                        changed: false,
+                        snapshot: inspected.snapshot,
+                        operations: [],
+                        error: { code: 'GIT_HEAD_MISMATCH', message: `Expected HEAD ${input.expectedHead}, received ${inspected.snapshot.head}` }
+                    };
+                const currentTree = gitText(input.cwd, ['rev-parse', 'HEAD^{tree}']);
+                if (currentTree !== input.expectedTree)
+                    return {
+                        status: 'failed',
+                        changed: false,
+                        snapshot: inspected.snapshot,
+                        operations: [],
+                        error: { code: 'GIT_TREE_MISMATCH', message: `Expected current tree ${input.expectedTree}, received ${currentTree}` }
+                    };
                 return {
-                    status: 'failed',
+                    status: 'no-op',
                     changed: false,
                     snapshot: inspected.snapshot,
-                    operations: [],
-                    error: { code: 'GIT_TREE_MISMATCH', message: `Expected current tree ${input.expectedTree}, received ${currentTree}` }
+                    operations: [{ name: 'commit', status: 'no-op' }],
+                    error: null
                 };
-            return {
-                status: 'no-op',
-                changed: false,
-                snapshot: inspected.snapshot,
-                operations: [{ name: 'commit', status: 'no-op' }],
-                error: null
-            };
-        })()
-        : commitExplicitPaths({
-            cwd: input.cwd,
-            paths: input.paths,
-            message: input.message,
-            expectedHead: input.expectedHead,
-            expectedTree: input.expectedTree
-        });
+            })()
+            : commitExplicitPaths({
+                cwd: input.cwd,
+                paths: input.paths,
+                message: input.message,
+                expectedHead: input.expectedHead,
+                expectedTree: input.expectedTree
+            });
     if (committed.status === 'failed')
         return {
             ...committed,
@@ -241,42 +346,42 @@ function executeUnlocked(input, task, mode) {
             snapshot: committed.snapshot
         };
     const warnings = [];
-    if (orchestrationCompletion) {
-        try {
-            commitOrchestrationStageCompletion(orchestrationCompletion);
-        }
-        catch (error) {
-            warnings.push(warning('ORCHESTRATION_COMPLETION_FAILED', error instanceof Error ? error.message : String(error), true, 'orchestration', task?.taskId ?? 'orchestration', 'ACTION_REQUIRED'));
-        }
-    }
     let status = committed.status;
     let result = committed.status === 'applied' ? 'committed' : 'no_op';
-    const target = `${input.push.remote}:${input.push.refs[0]}`;
-    const decision = commitPushDecision({ branch }, target);
-    if (!decision.shouldPush) {
-        warnings.push(decision.warning);
-    }
-    else {
-        const pushed = pushGitRefs({
-            cwd: input.cwd,
-            remote: input.push.remote,
-            refs: input.push.refs,
-            expectedSha: committed.snapshot?.head ?? gitText(input.cwd, ['rev-parse', 'HEAD'])
-        });
-        if (pushed.status !== 'applied')
-            warnings.push(warning('COMMIT_PUSH_FAILED', pushed.error?.message ?? 'Git push failed', true, 'push', target, 'ACTION_REQUIRED'));
+    if (delivery.mode === 'push') {
+        const target = `${delivery.remote}:${delivery.refs[0]}`;
+        const decision = commitPushDecision({ branch }, target);
+        if (!decision.shouldPush) {
+            warnings.push(decision.warning);
+        }
+        else {
+            const pushed = pushGitRefs({
+                cwd: input.cwd, remote: delivery.remote, refs: delivery.refs,
+                expectedSha: committed.snapshot?.head ?? gitText(input.cwd, ['rev-parse', 'HEAD'])
+            });
+            if (pushed.status !== 'applied')
+                warnings.push(warning('COMMIT_PUSH_FAILED', pushed.error?.message ?? 'Git push failed', true, 'push', target, 'ACTION_REQUIRED'));
+        }
     }
     if (warnings.length > 0) {
         status = 'applied';
         result = 'committed_with_warnings';
     }
     if (task && (committed.status === 'applied' || committed.status === 'no-op')) {
-        const taskWarning = syncTaskCommit(input, task, committed.snapshot?.head ?? gitText(task.repoRoot, ['rev-parse', 'HEAD']));
+        const committedHead = checkpointCommittedHead ?? committed.snapshot?.head ?? gitText(task.repoRoot, ['rev-parse', 'HEAD']);
+        const taskWarning = syncTaskCommit(input, task, committedHead);
         if (taskWarning) {
             warnings.push(taskWarning);
             status = 'applied';
             result = 'committed_with_warnings';
         }
+        if (delivery.mode === 'local' && !taskWarning && pendingIntent && checkpointCommittedHead) {
+            const synced = updateCheckpointIntent(pendingIntent, {
+                state: 'synced', committedHead: checkpointCommittedHead, updatedAt: checkpointTimestamp()
+            });
+            writeCheckpointIntent(task.repoRoot, synced);
+            removeCheckpointIntent(task.repoRoot, task.taskId);
+        }
     }
     return {
         status,

package/dist/lib/task/control-authority.js

@@ -101,12 +101,12 @@ function lifecycleTaskId(request, repoRoot) {
         return null;
     }
 }
-function applyLifecycleWithAuthority(context, request) {
+async function applyLifecycleWithAuthority(context, request) {
     const conflict = overrideDryRunConflict(request);
     if (conflict) {
         return taskLifecycleFailure(request, { code: 'LIFECYCLE_PAYLOAD_INVALID', message: conflict.message });
     }
-    const execute = () => {
+    const execute = async () => {
         const lifecycleResult = applyTaskLifecycle(request, { repoRoot: context.repoRoot });
         if (lifecycleResult.status !== 'failed' || !request.overrideTicket)
             return lifecycleResult;
@@ -116,7 +116,7 @@ function applyLifecycleWithAuthority(context, request) {
                 error: { code: 'OVERRIDE_PAYLOAD_INVALID', message: 'override ticket requires --override-target and --override-scope' }
             };
         }
-        const override = consumeHumanOverride({
+        const override = await consumeHumanOverride({
             taskRef: request.taskRef,
             ticketId: request.overrideTicket,
             failureId: failureId('lifecycle.apply', lifecycleResult.error?.code ?? 'LIFECYCLE_FAILED'),
@@ -133,9 +133,9 @@ function applyLifecycleWithAuthority(context, request) {
     };
     const taskId = lifecycleTaskId(request, context.repoRoot);
     if (!taskId)
-        return execute();
+        return await execute();
     try {
-        return withTaskExecutionLock(context.repoRoot, taskId, `task-lifecycle.${request.intent}`, execute);
+        return await withTaskExecutionLock(context.repoRoot, taskId, `task-lifecycle.${request.intent}`, execute);
     }
     catch (error) {
         if (!(error instanceof TaskExecutionLockError))
@@ -210,6 +210,9 @@ export function dispatchTaskControlOperation(context, operation) {
         operationTaskId(context, operation.request.taskRef);
         return applyTaskFinalization(operation.request, {
             repoRoot: context.repoRoot,
+            ...(context.source === 'sandbox-executor' ? {
+                controlBinding: { generation: context.generation, requestId: context.requestId }
+            } : {}),
             preflight: (request, options) => verifyTaskEvent({ ...request, event: 'complete-task.hard-preflight' }, options)
         });
     }