@godv61/dsh-task-engine 0.23.0 → 0.23.2

package/lib/dev-task.js

@@ -18,6 +18,7 @@ import { defineTool } from '@deepseek-ai/dsh-tools';
 import { assertAdvance, bindingsForStage, checkFileScope, commitCheckpoint, legalTargets, newTask, taskIdFromMessage, unmetGuards, validateCommitMessage, validateWorkflow, } from "./engine.js";
 import { HIGH_RISK_REQUIRED_CAPABILITIES, flowSatisfies, resolveFlow, } from "./workflows.js";
 import { hashConfig, hashText } from "./snapshot.js";
+import { loadedSkills, needsSkillReceipt, obligationStages, skillBlockers } from "./skill-audit.js";
 import { detectRoot, detectType, defaultVerifyCommand, listProjectRules, listProjectSkills, presentGovernanceFiles, } from "./project.js";
 /** Bundled commit-msg hook, copied into `.git/hooks/` by the `install_hook` operation. */
 const HOOK_TEMPLATE = readFileSync(fileURLToPath(new URL('../hooks/commit-msg', import.meta.url)), 'utf8');
@@ -101,15 +102,22 @@ const VERIFY_TIMEOUT_MS = 10 * 60 * 1000;
  * objective {@link VerificationReceipt}; `passed` derives from the exit code,
  * never from the model's claim.
  */
-async function runVerificationCommand(ctx, command, cwd) {
+async function runVerificationCommand(ctx, command, cwd, exec, approvedMode) {
     const shell = ctx.get('shell');
     if (shell === undefined) {
         throw new Error('verify 带 command 需要 host 提供 shell 服务（用于跑真实验证命令），但当前未挂载');
     }
     const started_at = new Date().toISOString();
-    const spec = shell.resolve(cwd !== undefined
-        ? { command, workdir: cwd, timeoutMs: VERIFY_TIMEOUT_MS }
-        : { command, timeoutMs: VERIFY_TIMEOUT_MS });
+    const policyService = ctx.get('sandboxPolicy');
+    if (approvedMode !== undefined && policyService === undefined) {
+        throw new Error('verification sandbox override requires the host sandboxPolicy service');
+    }
+    const standingPolicy = policyService?.resolve({ session: exec.agent?.session });
+    const sandboxPolicy = approvedMode === undefined ? standingPolicy : { ...standingPolicy, mode: approvedMode };
+    const spec = shell.resolve({ command, ...(cwd !== undefined ? { workdir: cwd } : {}),
+        timeoutMs: VERIFY_TIMEOUT_MS, signal: exec.signal,
+        ...(sandboxPolicy ? { sandboxPolicy } : {}),
+    });
     const outcome = await shell.run(spec);
     return {
         command,
@@ -121,6 +129,7 @@ async function runVerificationCommand(ctx, command, cwd) {
         ...(cwd !== undefined ? { root: cwd } : {}),
         stdout: outcome.stdout?.text ?? '',
         stderr: outcome.stderr?.text ?? '',
+        ...(outcome.sandbox ? { sandbox: outcome.sandbox } : {}),
     };
 }
 function sanitize(id) {
@@ -254,7 +263,7 @@ async function writeTask(fs, state, cwd, mode) {
     }
 }
 /**
- * Resolve the sandbox mode this call's writes run under. No escalation args:
+ * Resolve the sandbox mode before this call's writes or verification command. No escalation args:
  * workspace-write. Escalation args must travel as the `sandbox_permissions` ⇔
  * `justification` pair (mirroring the harness escalation contract), and a
  * `danger-full-access` request must earn a one-shot human approval; without an
@@ -283,7 +292,9 @@ async function resolveWriteMode(ctx, args, exec) {
         agent: exec.agent,
         toolName: 'dev_task',
         callId: exec.callId,
-        reason: `沙箱升级：请确认允许 dev_task 以 ${mode} 模式写任务文件（workspace: ${workspace}）。理由：${args.justification}`,
+        reason: args.command !== undefined
+            ? `沙箱升级：请确认允许 dev_task 以 ${mode} 模式执行本次验证命令并保存回执（workspace: ${workspace}）。命令：${args.command}\n理由：${args.justification}`
+            : `沙箱升级：请确认允许 dev_task 以 ${mode} 模式写任务文件（workspace: ${workspace}）。理由：${args.justification}`,
         signal: exec.signal,
     });
     if (outcome !== 'allowed-once') {
@@ -351,14 +362,14 @@ async function resolveRules(names, fs, cwd) {
             result.push({ name: rawName, content: bundled });
             continue;
         }
-        const user = readAbsRule(join(dshHome(), 'rules', `${name}.md`));
-        if (user !== undefined) {
-            result.push({ name: rawName, content: user });
-            continue;
-        }
         const project = await readText(fs, `.dsh/rules/${name}.md`, cwd);
-        if (project !== undefined)
+        if (project !== undefined) {
             result.push({ name: rawName, content: project });
+            continue;
+        }
+        const user = readAbsRule(join(dshHome(), 'rules', `${name}.md`));
+        if (user !== undefined)
+            result.push({ name: rawName, content: user });
     }
     return result;
 }
@@ -384,15 +395,75 @@ async function renderBindings(stage, workflow, fs, cwd) {
     const rulePart = rules.length > 0
         ? `rules for this stage:\n${rules.map(r => `### ${r.name}\n${r.content}`).join('\n\n')}`
         : '';
-    return [skillPart, rulePart].filter(Boolean).join('\n');
+    const additional = skills.filter(needsSkillReceipt);
+    const receiptPart = additional.length
+        ? `additional skills requiring skill_result command receipts: ${additional.join(', ')}`
+        : 'skill_result not required for this stage: core skills use record/verify/review/commit gates';
+    return [skillPart, receiptPart, rulePart].filter(Boolean).join('\n');
 }
 /** Normalize the tool's `items` argument into complete TaskItem records. */
-function normalizeItems(items) {
-    return (items ?? []).map(item => ({
-        id: String(item.id ?? ''),
-        title: String(item.title ?? ''),
-        status: item.status ?? 'todo',
-    }));
+function normalizeItems(items, previous = []) {
+    const ids = new Set();
+    const result = (items ?? []).map(item => {
+        const id = String(item.id ?? '').trim();
+        const old = previous.find(entry => entry.id === id);
+        const title = String(item.title ?? old?.title ?? '').trim();
+        if (!id || !title || ids.has(id))
+            throw new Error('items require non-empty unique id and title');
+        ids.add(id);
+        const status = item.status ?? old?.status ?? 'todo';
+        if (old?.review && old.title !== title && status === 'done') {
+            throw new Error(`item "${id}" has a review: omit title to preserve it, or reopen as todo/doing before changing its title and reviewing again`);
+        }
+        const unchanged = old?.title === title && !(old.status === 'done' && status !== 'done');
+        return { ...(unchanged ? old : {}), id, title, status };
+    });
+    if (result.filter(item => item.status === 'doing').length > 1)
+        throw new Error('only one implementation item may be doing');
+    return result;
+}
+/** Hash declared deliverables through host FS; task bookkeeping is excluded to avoid self-invalidation. */
+async function scopeFingerprint(fs, state, cwd) {
+    const entries = [];
+    for (const path of [...new Set(state.files)].filter(path => !/^\.dsh\/(task-[^/]+\.json|eng\.json)$/.test(path)).sort()) {
+        assertInsideRoot(state.root ?? cwd ?? '', state.root ?? cwd ?? '', path);
+        const root = state.root ?? cwd;
+        const target = await fs.resolve(path, root === undefined ? undefined : { cwd: root });
+        let content;
+        try {
+            content = await fs.readText(target);
+        }
+        catch (error) {
+            if (!['ENOENT', 'FS_NOT_FOUND'].includes(error.code ?? ''))
+                throw error;
+        }
+        entries.push([path, content === undefined ? null : hashText(content)]);
+    }
+    return hashText(JSON.stringify(entries));
+}
+/** A previous pass cannot authorize a changed tree. Commands still need meaningful human-reviewed coverage. */
+async function evidenceBlockers(fs, state, workflow, cwd) {
+    if (state.execution_version !== 1)
+        return [];
+    const blockers = [];
+    const current = await scopeFingerprint(fs, state, cwd);
+    if (state.verification.passed && state.verification.receipt?.scope_hash !== current) {
+        blockers.push('verification is missing or stale after file/scope changes; rerun verify with a real command');
+    }
+    for (const stage of obligationStages(state, workflow)) {
+        for (const [name, result] of Object.entries(state.skill_results?.[stage] ?? {})) {
+            if (!needsSkillReceipt(name))
+                continue;
+            if (result.receipt?.scope_hash !== current)
+                blockers.push(`skill_result for ${name} is stale after file/scope changes; rerun its validation command`);
+        }
+    }
+    return blockers;
+}
+async function assertFreshEvidence(fs, state, workflow, cwd) {
+    const blockers = await evidenceBlockers(fs, state, workflow, cwd);
+    if (blockers.length)
+        throw new Error(blockers.join('; '));
 }
 /** Resolve one item by id for the item-scoped audit operations. */
 function requireItem(state, id) {
@@ -431,7 +502,7 @@ export async function approveAdvance(ctx, state, target, workflow, confirmations
     });
     if (outcome !== 'allowed-once') {
         const verb = outcome === 'rejected' ? '被驳回' : outcome === 'cancelled' ? '已取消' : '无人批准';
-        return { ok: false, errors: [`${labels}确认${verb}，流转被拒绝`] };
+        return { ok: false, errors: [`${labels}确认${verb}，流转被拒绝。保持当前阶段；先获取用户的修改意见并修订，不要假定误操作或直接重复申请。`] };
     }
     if (confirmations.includes('requirement_confirmation'))
         state.requirement_confirmed = true;
@@ -439,7 +510,7 @@ export async function approveAdvance(ctx, state, target, workflow, confirmations
         state.solution_confirmed = true;
     return assertAdvance(state, target, workflow);
 }
-const OPERATIONS = ['status', 'create', 'record', 'items', 'scope', 'dispatch', 'review_item', 'advance', 'verify', 'review', 'commit', 'config', 'install_hook', 'verify_hook', 'init', 'set_risk'];
+const OPERATIONS = ['status', 'create', 'record', 'items', 'scope', 'dispatch', 'review_item', 'advance', 'verify', 'review', 'commit', 'config', 'install_hook', 'verify_hook', 'init', 'set_risk', 'skill_result'];
 const TOOL_DESCRIPTION = 'Own the engineering delivery workflow as hard state. Read or create the task record, record a ' +
     'stage artifact, record each implementation item\'s subagent dispatch and two-stage (spec + quality) ' +
     'review audit, advance one stage (rejected unless every configured guard already holds, including ' +
@@ -461,14 +532,15 @@ export function registerDevTask(ctx) {
         description: TOOL_DESCRIPTION,
         parameters: {
             operation: { type: 'string', enum: [...OPERATIONS], required: true, description: 'Which task-record action to perform.' },
-            task_id: { type: 'string', description: 'Task id (short stable id like GREET-001); required on create and every other operation.' },
+            task_id: { type: 'string', description: 'Task id. Omit on status to discover tasks in the current workspace; optionally filter by branch.' },
+            skill_name: { type: 'string', description: 'Bound skill to record after executing it (skill_result): requires prior successful skill load, evidence and a real validation command. target_stage may name the upcoming terminal stage.' },
             branch: { type: 'string', description: 'Current git branch (recorded on create).' },
             title: { type: 'string', description: 'Task title (create).' },
             work_size: { type: 'string', enum: ['tiny', 'standard', 'complex'], description: 'Workload tier (create).' },
             risk_level: { type: 'string', enum: ['standard', 'high_risk'], description: 'Risk tier (create).' },
             items: {
                 type: 'array',
-                description: 'Implementation items (create/update).',
+                description: 'Full implementation item list (create/replace). For an existing id, omit title to preserve its title and audit. Changing a reviewed title requires reopening as todo/doing and reviewing again. Include every item to retain.',
                 items: {
                     type: 'object',
                     additionalProperties: false,
@@ -484,15 +556,15 @@ export function registerDevTask(ctx) {
             spec_outcome: { type: 'string', enum: ['pass', 'fail'], description: 'Specification-conformance verdict (review_item).' },
             quality_outcome: { type: 'string', enum: ['pass', 'fail'], description: 'Code-quality verdict (review_item).' },
             notes: { type: 'array', items: { type: 'string' }, description: 'Findings or defects (review_item).' },
-            target_stage: { type: 'string', description: 'Stage to advance to (advance).' },
-            command: { type: 'string', description: 'Verification command to run for a real receipt (verify); when set, passed derives from its exit code instead of the model claim.' },
-            passed: { type: 'boolean', description: 'Verification passed (verify), used only when no command is given.' },
+            target_stage: { type: 'string', description: 'Stage to advance to, or current/upcoming terminal skill binding stage for skill_result.' },
+            command: { type: 'string', description: 'Real acceptance command for verify/skill_result. New tasks require command receipts. Propagate failures when composing shell commands.' },
+            passed: { type: 'boolean', description: 'Legacy tasks only: verification claim when no command can be resolved. New tasks require real command receipts.' },
             evidence: { type: 'array', items: { type: 'string' }, description: 'Supplementary verification evidence (verify).' },
             outcome: { type: 'string', enum: ['pass', 'blocked'], description: 'Review outcome (review).' },
-            artifact: { type: 'string', description: 'Artifact id to record fields for (record).' },
+            artifact: { type: 'string', description: 'Artifact id from status.artifact_requirements for the current stage (record).' },
             fields: {
                 type: 'object',
-                description: 'Field values for the artifact (record).',
+                description: 'Field values using only keys listed by status.artifact_requirements (record). Put questions and tradeoffs inside an allowed text field, not new keys. Allowed fields come from the frozen workflow and may differ between presets.',
                 additionalProperties: true,
             },
             files: {
@@ -506,7 +578,7 @@ export function registerDevTask(ctx) {
             overwrite: { type: 'boolean', description: 'Allow replacing an existing AGENTS.md (init apply); triggers human approval.' },
             expected_hash: { type: 'string', description: 'The content hash returned by init phase=propose; apply is rejected without it, or with a different hash (init apply).' },
             existing_hash: { type: 'string', description: 'The existing-file hash returned by init phase=propose; when the current AGENTS.md exists, a mismatching existing_hash proves it changed during review (init apply).' },
-            sandbox_permissions: { type: 'string', enum: ['workspace-write', 'danger-full-access'], description: 'Wider sandbox mode for this call\'s file writes; default is workspace-write. Use only as a retry after a sandbox denial of the same call; requires justification and human approval.' },
+            sandbox_permissions: { type: 'string', enum: ['workspace-write', 'danger-full-access'], description: 'Sandbox mode for this call\'s file writes and verify/skill_result command. Commands otherwise use the session policy. Retry the exact denied command with justification; danger-full-access requires approval before execution and applies only to this call.' },
             justification: { type: 'string', description: 'Required with sandbox_permissions: one sentence for the user explaining why this exact operation needs the wider access.' },
             phase: { type: 'string', enum: ['inspect', 'propose', 'apply'], description: 'init phase: inspect (read-only), propose (preview draft, no write), apply (write; overwriting an existing file requires human approval).' },
         },
@@ -522,6 +594,20 @@ export function registerDevTask(ctx) {
             // The session workspace drives every relative path; the backend's own base
             // (its config.cwd) is the harness process directory, never the workspace.
             const cwd = exec.agent?.session.header.cwd;
+            const session = exec.agent?.session;
+            if (a.operation === 'status' && !a.task_id) {
+                const tasks = [];
+                const names = await projectProbe(fs).list?.(cwd ?? '', '.dsh') ?? [];
+                for (const name of names.filter(name => /^task-.+\.json$/.test(name))) {
+                    const raw = await readText(fs, `.dsh/${name}`, cwd);
+                    if (!raw)
+                        continue;
+                    const task = JSON.parse(raw);
+                    if (!a.branch || task.branch === a.branch)
+                        tasks.push({ id: task.id, title: task.title, branch: task.branch, stage: task.stage });
+                }
+                return JSON.stringify({ tasks, next_action: tasks.length ? 'Call status with the selected task_id; create a new task for a new requirement.' : 'No task found. Call create with task_id, title and current branch.' }, null, 2);
+            }
             if (a.operation === 'config') {
                 const resolved = await resolveWorkflow(fs, cwd);
                 return JSON.stringify({
@@ -651,11 +737,12 @@ export function registerDevTask(ctx) {
                     project_type: await detectType(projectProbe(fs), root),
                 });
                 state.items = normalizeItems(a.items);
+                state.execution_version = 1;
                 state.files = a.files ?? [];
                 state.bindings_fingerprint = builtinRulesFingerprint();
                 assertInsideRoot(root, cwd ?? '', taskPath(state.id));
                 await writeTask(fs, state, cwd, await resolveWriteMode(ctx, a, exec));
-                return `created ${state.id} at stage ${state.stage}; legal next: ${legalTargets(state.stage, flow.config).join(', ') || 'none'}`;
+                return `created ${state.id} at stage ${state.stage}; legal next: ${legalTargets(state.stage, flow.config).join(', ') || 'none'}\n${await renderBindings(state.stage, flow.config, fs, cwd)}\nBefore advance, load all bound skills. For additional skills, execute their instructions then use skill_result with evidence and command. Terminal bindings must finish before entering the terminal stage.`;
             }
             if (!a.task_id)
                 throw new Error('task_id is required for this operation');
@@ -664,6 +751,10 @@ export function registerDevTask(ctx) {
             if (a.operation === 'status') {
                 const binding = bindingsForStage(state.stage, workflow);
                 const rules = await resolveRules(binding?.rules ?? [], fs, cwd);
+                const missingSkills = skillBlockers(state, workflow, session);
+                const staleEvidence = await evidenceBlockers(fs, state, workflow, cwd);
+                const checkpoint = commitCheckpoint(state, workflow);
+                const commitBlockers = [...staleEvidence, ...missingSkills];
                 return JSON.stringify({
                     id: state.id,
                     stage: state.stage,
@@ -673,12 +764,27 @@ export function registerDevTask(ctx) {
                     requirement_confirmed: state.requirement_confirmed,
                     solution_confirmed: state.solution_confirmed,
                     items_done: `${state.items.filter(i => i.status === 'done').length}/${state.items.length}`,
+                    items: state.items,
+                    skill_obligations: obligationStages(state, workflow).map(stage => ({
+                        stage, skills: workflow.stage_bindings?.[stage]?.skills ?? [],
+                        command_receipts_required: (workflow.stage_bindings?.[stage]?.skills ?? []).filter(needsSkillReceipt),
+                    })),
+                    skill_blockers: missingSkills,
+                    evidence_blockers: staleEvidence,
+                    skill_results: state.skill_results ?? {},
+                    commits: state.commits,
                     verification: state.verification,
                     review: state.review,
+                    artifact_requirements: workflow.artifacts.filter(def => def.stage === state.stage).map(def => ({
+                        id: def.id, name: def.name, fields: def.fields,
+                        missing_fields: def.fields.filter(field => !(state.artifacts[def.id]?.[field] ?? '').trim()),
+                    })),
                     artifacts: state.artifacts,
                     files: state.files,
                     legal_next: legalTargets(state.stage, workflow),
-                    commit: commitCheckpoint(state, workflow),
+                    commit: checkpoint.allowed && commitBlockers.length
+                        ? { ...checkpoint, allowed: false, reason: commitBlockers.join('; ') }
+                        : checkpoint,
                     bindings: {
                         skills: binding?.skills ?? [],
                         rules: rules.map(r => ({ name: r.name, content: r.content })),
@@ -690,6 +796,10 @@ export function registerDevTask(ctx) {
                 }, null, 2);
             }
             if (a.operation === 'commit') {
+                await assertFreshEvidence(fs, state, workflow, cwd);
+                const missingSkills = skillBlockers(state, workflow, session);
+                if (missingSkills.length)
+                    throw new Error(missingSkills.join('; '));
                 const checkpoint = commitCheckpoint(state, workflow);
                 if (!checkpoint.allowed)
                     throw new Error(checkpoint.reason ?? 'no commit is due');
@@ -711,12 +821,30 @@ export function registerDevTask(ctx) {
                 if (committedId !== undefined && committedId !== state.id) {
                     throw new Error(`commit summary names task "${committedId}" but this operation targets "${state.id}" — put the target task id in the summary`);
                 }
-                if (a.hash)
-                    state.commits.push({ label: checkpoint.label, hash: a.hash });
+                if (a.hash) {
+                    if (!/^[0-9a-f]{7,40}$/i.test(a.hash))
+                        throw new Error('commit hash must be a Git object id');
+                    if (state.execution_version === 1) {
+                        const receipt = await runVerificationCommand(ctx, 'git -c core.quotepath=false log -1 --format=%H%n%s%n --name-only HEAD', state.root ?? cwd, exec);
+                        if (receipt.exit_code !== 0 || receipt.aborted || receipt.timed_out || receipt.sandbox?.denied || receipt.sandbox?.runnerFailed)
+                            throw new Error('cannot verify the recorded Git commit');
+                        const lines = receipt.stdout.trim().split(/\r?\n/);
+                        if (!lines[0]?.startsWith(a.hash) || lines[1] !== a.message)
+                            throw new Error('Git commit does not match the approved hash and summary');
+                        const paths = lines.slice(2).map(line => line.trim()).filter(Boolean);
+                        if (!paths.length || (workflow.commit.file_scope && !checkFileScope(state, paths, workflow).ok))
+                            throw new Error('actual committed files do not match the task scope');
+                    }
+                    if (!state.commits.some(entry => entry.hash === a.hash))
+                        state.commits.push({ label: checkpoint.label, hash: a.hash });
+                }
                 await writeTask(fs, state, cwd, await resolveWriteMode(ctx, a, exec));
+                if (a.hash)
+                    return `commit recorded (${checkpoint.label ?? ''}): ${a.hash}; use status to inspect remaining gates, then advance`;
                 return `commit approved (${checkpoint.label ?? ''}) — git add ${(a.files ?? []).join(' ')}; git commit -m "${a.message ?? ''}"`;
             }
             let note;
+            let approvedWriteMode;
             switch (a.operation) {
                 case 'record': {
                     if (!a.artifact)
@@ -731,7 +859,7 @@ export function registerDevTask(ctx) {
                     const merged = { ...(state.artifacts[def.id] ?? {}) };
                     for (const [field, value] of Object.entries(a.fields ?? {})) {
                         if (!def.fields.includes(field)) {
-                            throw new Error(`artifact "${def.id}" has no field "${field}"; fields: ${def.fields.join(', ')}`);
+                            throw new Error(`artifact "${def.id}" has no field "${field}"; fields: ${def.fields.join(', ')}. Read status.artifact_requirements and put additional questions or tradeoffs inside an allowed text field, not a new key. No changes were saved.`);
                         }
                         merged[field] = value === undefined || value === null ? '' : String(value);
                     }
@@ -747,13 +875,17 @@ export function registerDevTask(ctx) {
                     note = `file scope set to ${state.files.length} files${state.files.length > 0 ? ': ' + state.files.join(', ') : ' (empty — commits are blocked until files are declared)'}`;
                     break;
                 case 'items':
-                    state.items = normalizeItems(a.items);
+                    state.items = normalizeItems(a.items, state.items);
                     note = `items set: ${state.items.map(i => `${i.id}:${i.status}`).join(', ') || 'none'}`;
                     break;
                 case 'dispatch': {
                     const item = requireItem(state, a.item_id);
+                    if (state.items.some(other => other.id !== item.id && other.status === 'doing'))
+                        throw new Error('finish or pause the current doing item before dispatching another item');
+                    item.status = 'doing';
+                    delete item.review;
                     item.dispatch = { description: a.description ?? '', at: new Date().toISOString() };
-                    note = `dispatched item "${item.id}" to a subagent: ${item.dispatch.description || '(no description)'}`;
+                    note = `item "${item.id}" is doing; dispatch intent recorded: ${item.dispatch.description || '(no description)'}. Now invoke the subagent; after it returns, review_item then items(done).`;
                     break;
                 }
                 case 'review_item': {
@@ -772,6 +904,10 @@ export function registerDevTask(ctx) {
                 }
                 case 'advance': {
                     const target = a.target_stage ?? '';
+                    await assertFreshEvidence(fs, state, workflow, cwd);
+                    const missingSkills = skillBlockers(state, workflow, session);
+                    if (missingSkills.length)
+                        throw new Error(missingSkills.join('; '));
                     let result = assertAdvance(state, target, workflow);
                     if (!result.ok) {
                         const unmet = unmetGuards(state, target, workflow);
@@ -786,7 +922,9 @@ export function registerDevTask(ctx) {
                         throw new Error(result.errors.join('; '));
                     state.stage = target;
                     const disclosure = await renderBindings(state.stage, workflow, fs, cwd);
-                    note = disclosure === '' ? `advanced to ${state.stage}` : `advanced to ${state.stage}\n${disclosure}`;
+                    const terminalObligations = obligationStages(state, workflow).filter(stage => stage !== state.stage);
+                    const terminalDisclosure = await Promise.all(terminalObligations.map(async (stage) => `Before entering ${stage}, execute its bindings now:\n${await renderBindings(stage, workflow, fs, cwd)}`));
+                    note = [`advanced to ${state.stage}`, disclosure, ...terminalDisclosure].filter(Boolean).join('\n');
                     break;
                 }
                 case 'set_risk': {
@@ -840,19 +978,43 @@ export function registerDevTask(ctx) {
                     const verifyRoot = state.root ?? cwd;
                     const command = explicit ? a.command.trim() : await resolveVerifyCommand(fs, verifyRoot);
                     if (command !== undefined) {
-                        const receipt = await runVerificationCommand(ctx, command, verifyRoot);
+                        approvedWriteMode = await resolveWriteMode(ctx, { ...a, command }, exec);
+                        const receipt = await runVerificationCommand(ctx, command, verifyRoot, exec, a.sandbox_permissions === undefined ? undefined : approvedWriteMode);
+                        if (state.execution_version === 1)
+                            receipt.scope_hash = await scopeFingerprint(fs, state, cwd);
                         if (receipt.root !== undefined && receipt.root !== verifyRoot) {
                             throw new Error(`verification receipt root mismatch: ${receipt.root} vs task root ${String(verifyRoot)}`);
                         }
                         state.verification = {
-                            passed: receipt.exit_code === 0 && !receipt.timed_out && !receipt.aborted,
+                            passed: receipt.exit_code === 0 && !receipt.timed_out && !receipt.aborted && !receipt.sandbox?.denied && !receipt.sandbox?.runnerFailed,
                             evidence: a.evidence ?? [],
                             receipt,
                         };
                     }
                     else {
+                        if (state.execution_version === 1)
+                            throw new Error('verify requires a real validation command; pass command explicitly for this project');
                         state.verification = { passed: a.passed === true, evidence: a.evidence ?? [] };
                     }
+                    note = JSON.stringify({ ok: state.verification.passed, stage: state.stage, verification: state.verification }, null, 2);
+                    break;
+                }
+                case 'skill_result': {
+                    const stage = a.target_stage ?? state.stage;
+                    if (!obligationStages(state, workflow).includes(stage) || !workflow.stage_bindings?.[stage]?.skills?.includes(a.skill_name ?? ''))
+                        throw new Error('skill_result requires a skill bound to this stage or its upcoming terminal stage');
+                    const loadCall = loadedSkills(session).get(a.skill_name);
+                    if (!loadCall)
+                        throw new Error(`load skill "${a.skill_name}" successfully before recording execution`);
+                    if (!a.command?.trim() || !a.evidence?.length || a.evidence.some(value => !value.trim()))
+                        throw new Error('skill_result requires a real validation command and non-empty evidence describing executed scenarios and results');
+                    approvedWriteMode = await resolveWriteMode(ctx, a, exec);
+                    const receipt = await runVerificationCommand(ctx, a.command, state.root ?? cwd, exec, a.sandbox_permissions === undefined ? undefined : approvedWriteMode);
+                    receipt.scope_hash = await scopeFingerprint(fs, state, cwd);
+                    state.skill_results ??= {};
+                    state.skill_results[stage] ??= {};
+                    state.skill_results[stage][a.skill_name] = { session_id: session?.id ?? '', load_call_id: loadCall, evidence: a.evidence, receipt };
+                    note = JSON.stringify({ skill: a.skill_name, stage, receipt }, null, 2);
                     break;
                 }
                 case 'review':
@@ -863,7 +1025,7 @@ export function registerDevTask(ctx) {
                 default:
                     throw new Error(`unknown operation ${a.operation}`);
             }
-            await writeTask(fs, state, cwd, await resolveWriteMode(ctx, a, exec));
+            await writeTask(fs, state, cwd, approvedWriteMode ?? await resolveWriteMode(ctx, a, exec));
             return note ?? `ok (stage ${state.stage})`;
         },
     }));