@milpa/comal 0.2.2 → 0.2.4

package/src/work-assertions.mjs

@@ -16,18 +16,29 @@ export function validateAssertions(assertions = []) {
     if (assertion.pointer && (!assertion.pointer.startsWith('/') || assertion.pointer.split('/').some(part => ['__proto__', 'constructor', 'prototype'].includes(part)))) throw new Error('Invalid JSON pointer.');
   }
 }
+// An MCP receipt stores its result as JSON, so text the model read (quotes, newlines) is escaped there.
+// Text assertions also look inside each text block (never across two); an error result never counts (tools often echo their input).
+// A tool that shows a returned value as a JSON string in a ```json fence (chrome-devtools evaluate_script) escapes
+// its quotes once more: the decoded string is also searchable.
+const fencedStrings = text => [...text.matchAll(/```json\n([\s\S]*?)\n```/g)].flatMap(([, body]) => { try { const value = JSON.parse(body); return typeof value === 'string' ? [value] : []; } catch { return []; } });
+const mcpText = output => {
+  if (!output.startsWith('{"content":[')) return null;
+  try { const result = JSON.parse(output), blocks = result.content; return Array.isArray(blocks) && result.is_error !== true && result.isError !== true ? blocks.filter(block => block?.type === 'text' && typeof block.text === 'string').flatMap(block => [block.text, ...fencedStrings(block.text)]) : null; } catch { return null; }
+};
 export function assertOutput(output, assertions = []) {
   validateAssertions(assertions);
-  for (const assertion of assertions) {
+  const text = assertions.some(assertion => ['contains', 'not_contains'].includes(assertion.kind)) ? mcpText(output) : null;
+  const has = value => output.includes(value) || Boolean(text?.some(block => block.includes(value)));
+  for (const [index, assertion] of assertions.entries()) {
     let passed = false;
     if (assertion.kind === 'nonempty') passed = Boolean(output.trim()) && !/^\((?:sin (?:salida|coincidencias)|no (?:output|matches))\)$/.test(output.trim());
-    if (assertion.kind === 'contains') passed = output.includes(assertion.value);
-    if (assertion.kind === 'not_contains') passed = !output.includes(assertion.value);
+    if (assertion.kind === 'contains') passed = has(assertion.value);
+    if (assertion.kind === 'not_contains') passed = !has(assertion.value);
     if (assertion.kind === 'json_equals') {
       let value; try { value = JSON.parse(output); } catch { throw Object.assign(new Error('The check did not return JSON for json_equals.'), { code: 'WORK_ASSERTION' }); }
       for (const part of assertion.pointer ? assertion.pointer.slice(1).split('/').map(part => part.replace(/~1/g, '/').replace(/~0/g, '~')) : []) value = value && Object.hasOwn(value, part) ? value[part] : undefined;
       passed = isDeepStrictEqual(value, assertion.value);
     }
-    if (!passed) throw Object.assign(new Error(`Assertion failed: ${assertion.kind}${assertion.pointer ? ' ' + assertion.pointer : ''}. Inspect the evidence; recheck preserves the same step_id.`), { code: 'WORK_ASSERTION' });
+    if (!passed) throw Object.assign(new Error(`Assertion failed: ${assertion.kind}${assertion.pointer ? ' ' + assertion.pointer : ''}${typeof assertion.value === 'string' ? ' ' + JSON.stringify(assertion.value.slice(0, 120)) : ''} (assertion ${index + 1} of ${assertions.length}). Inspect the evidence; recheck preserves the same step_id.`), { code: 'WORK_ASSERTION' });
   }
 }

package/src/work-plan.mjs

@@ -15,6 +15,7 @@ export const WORK_NAMES = ['WorkPlanSet', 'WorkCheckRepair', 'WorkTaskUpdate', '
 const id = { type: 'string', pattern: '^[A-Za-z0-9][A-Za-z0-9_.:-]{0,63}$' }, version = { type: 'integer', minimum: 0 };
 const args = { type: 'object' }, str = maxLength => ({ type: 'string', minLength: 1, maxLength });
 const schema = (properties, required) => ({ type: 'object', properties, required, additionalProperties: false });
+const MAX_TASK_CHECKS = 4;
 const keyOf = (task, step) => JSON.stringify([task, step]);
 const failure = (message, code = 'WORK_CONFLICT') => Object.assign(new Error(message), { code });
 export const planControl = work => ({ plan_exists: Boolean(work?.plan), expected_version: work?.plan?.version || 0,
@@ -22,6 +23,21 @@ export const planControl = work => ({ plan_exists: Boolean(work?.plan), expected
 
 // A generation owns produced work; its current check definition has a separate hash.
 export const workDigest = task => task?.work_digest || task?.definition_digest;
+// A close guard that requires a check the task never declared offers the exact
+// replan: retire the task and redeclare it under the same id with that check, so
+// dependents stay valid and the requirement is satisfied, never skipped.
+function withRequiredCheckRecovery(error, task, book) {
+  const { capability, check } = error.required_check, own = definitionOf(task), taken = new Set((own.checks || []).map(c => c.step_id));
+  let stepId = check.step_id; for (let n = 2; taken.has(stepId); n++) stepId = `${check.step_id}-${n}`;
+  // A task holds at most MAX_TASK_CHECKS; when full, the last check moves to a dependent task so the
+  // call stays valid and no declared check is dropped.
+  const checks = own.checks || [], keep = checks.length < MAX_TASK_CHECKS ? checks : checks.slice(0, MAX_TASK_CHECKS - 1), moved = checks.slice(keep.length);
+  const replacement = { ...own, capabilities: [...new Set([...(own.capabilities || []), capability])], checks: [...keep, { ...check, step_id: stepId }] };
+  const ids = new Set([...book.tasks.keys?.() ?? Object.keys(book.tasks || {})]); let restId = `${task.id}-checks`.slice(0, 64); for (let n = 2; ids.has(restId); n++) restId = `${task.id}-checks-${n}`.slice(0, 64);
+  const rest = moved.length ? [{ id: restId, title: `${own.title} (checks restantes)`.slice(0, 300), criterion: own.criterion, ...(own.phase ? { phase: own.phase } : {}), depends_on: [task.id], checks: moved }] : [];
+  const recovery_call = { name: 'WorkPlanSet', input: { expected_version: book.plan.version, append: true, objective: book.plan.objective, retire_ids: [task.id], reason: `Redeclare ${task.id} with the check the house requires to close it.`, tasks: [replacement, ...rest] } };
+  return Object.assign(new Error(`${error.message} ${JSON.stringify({ recovery_call, next_action: 'Run recovery_call as a top-level call: it keeps the task id, its work and its dependents, and adds the required check. Then set the task in_progress, run the new check when it can pass, and close. WorkCheckRepair cannot add checks.' })}`), { code: error.code });
+}
 const definitionOf = task => Object.fromEntries(['id','title','criterion','phase','capabilities','artifacts','depends_on','checks'].filter(key => task[key] !== undefined).map(key => [key,task[key]]));
 const isMcpCheck = check => /^mcp(?:__|:)/.test(check.operation);
 const mcpServer = check => /^mcp:([^\s]+)/.exec(check.operation)?.[1] || /^mcp__(.+?)__/.exec(check.operation)?.[1];
@@ -96,6 +112,21 @@ function closedProcessFailure(session,step,audit,active){
   return {kind:'native_process_nonzero_exit',exit_code:Number(match[1]),receipt_id:leaf.invocation_id,parent_receipt_id:parent.invocation_id,derivation:exits.length?'native_process_exit_observation':'legacy_native_shell_error',partial_effects:'preserved_unjudged',retry_authorized:false};
 }
 
+// An MCP server that answers a step with its own error result (is_error) has already judged the call:
+// the house records the failure (the CLI raises that result as the tool error), and the step closes like
+// a shell exit code. Effects stay unjudged; nothing retries that step id, and new steps are not fenced.
+function closedMcpErrorResult(session,step,audit,active){
+  if(step.status!=='failed'||!/^mcp__.+__.+$/.test(step.operation||'')||active.has(step.invocation_id)||!audit.journal.verified||audit.violations.length||audit.unverified.length)return null;
+  const rows=session.rows,leaf=audit.receipts.find(row=>row.invocation_id===step.receipt_id),parent=audit.receipts.find(row=>row.invocation_id===step.invocation_id);
+  if(!leaf||!parent||leaf.code||leaf.status!=='failed'||parent.status!=='failed'||leaf.parent_invocation_id!==parent.invocation_id||parent.operation!=='WorkStepRun'||leaf.operation!==step.operation||leaf.error!==parent.error)return null;
+  const proposal=rows.find(row=>row.type==='house_proposal'&&row.invocation_id===parent.invocation_id);
+  const contract=rows.findLast(row=>row.type==='house_contract'&&row.contract_digest===leaf.contract_digest)?.contract;
+  if(!proposal||!nativeWorkParent(rows,proposal)||contract?.name!==step.operation||contract.origin?.kind!=='mcp')return null;
+  let result;try{result=JSON.parse(leaf.error||'');}catch{return null;}
+  if(!result||typeof result!=='object'||result.is_error!==true||!Array.isArray(result.content))return null;
+  return {kind:'mcp_error_result',receipt_id:leaf.invocation_id,parent_receipt_id:parent.invocation_id,server:contract.origin.server||null,partial_effects:'preserved_unjudged',external_effects:'unjudged',retry_authorized:false};
+}
+
 // This closes only a native file handler's known pre-replacement failure. It
 // neither credits its check nor retries that step; directories/temp files may
 // already exist. Plugin error text or a source error code alone is insufficient.
@@ -166,7 +197,9 @@ function foldWorkWithAudit(session, { active = new Set() } = {},auditFor) {
     }
     if (row.source === 'work_host' && workDigest(tasks.get(row.task_id)) === row.task_digest) {
       const task = tasks.get(row.task_id);
-      if (row.type === 'work_task_changed') Object.assign(task, { status: row.status, reason: row.reason, receipt_ids: row.receipt_ids || [], dependency_proofs: row.dependency_proofs || {}, ref: i });
+      if (row.type === 'work_task_changed') Object.assign(task, { status: row.status, reason: row.reason, receipt_ids: row.receipt_ids || [], dependency_proofs: row.dependency_proofs || {}, ref: i,
+        // First start of the task: work done before a later block/resume still belongs to it.
+        started_ref: task.started_ref ?? (row.status === 'in_progress' ? i : undefined) });
       if (row.type === 'work_check_verified') attestations.set(keyOf(row.task_id, row.step_id), { ...row, ref: i });
       if (row.type === 'work_step_started') { steps.set(keyOf(row.task_id, row.step_id), { ...row, ref: i, status: active.has(row.invocation_id) ? 'running' : 'interrupted', receipt_id: null }); task.last_step = row.step_id; }
       if (row.type === 'work_draft_chunk') {
@@ -195,7 +228,7 @@ function foldWorkWithAudit(session, { active = new Set() } = {},auditFor) {
     if (proof) Object.assign(step, { status: 'refused', preflight_failure: proof, recovery_ref: proof.parent_receipt_ref,
       next_action: 'The target was not dispatched: an artifact preflight failed. Prepare the missing or invalid output with new work, then retry this original step under current permissions. No failed check was credited.' });
   }
-  for(const step of steps.values()){const proof=closedProcessFailure(session,step,audit,active)||closedSourcePreflight(session,step,audit,active)||closedMediaPreflight(session,step,audit,active)||closedArtifactProcessing(session,step,audit,active);if(proof)step.failure_closed=proof;}
+  for(const step of steps.values()){const proof=closedProcessFailure(session,step,audit,active)||closedMcpErrorResult(session,step,audit,active)||closedSourcePreflight(session,step,audit,active)||closedMediaPreflight(session,step,audit,active)||closedArtifactProcessing(session,step,audit,active);if(proof)step.failure_closed=proof;}
   // Explicit local operator review is an attestation, not reconstructed execution
   // success. Only sealed human-control receipts can review a closed native Bash
   // failure; raw facts and model prose never clear a fence.
@@ -267,9 +300,12 @@ function projectWork(book) {
   const preflightFailures = book.steps.filter(step => step.preflight_failure).map(step => {
     const task = book.tasks.find(task => task.id === step.task_id);
     return { task_id: step.task_id, step_id: step.step_id, status: 'not_dispatched', ...step.preflight_failure,
-      retry_call: step.preflight_failure.retry_call || { name: 'WorkStepRun', input: { task_id: step.task_id, plan_version: book.plan.version, step_id: step.step_id } },
+      // A directory never becomes hashable by retrying: no retry_call for the recovery grace to point at.
+      retry_call: step.preflight_failure.code === 'FILE_HASH_TYPE' ? undefined : step.preflight_failure.retry_call || { name: 'WorkStepRun', input: { task_id: step.task_id, plan_version: book.plan.version, step_id: step.step_id } },
       ...(task?.declared_status === 'blocked' && !task.held_by.length ? { resume_call: { name: 'WorkTaskUpdate', input: { task_id: task.id, plan_version: book.plan.version, status: 'in_progress' } } } : {}),
-      next_action: 'Prepare the missing or invalid artifact with a new step or publish the preserved draft; then retry_call under current permissions. If the task is blocked, resume_call only changes its recorded status. The failed check remains uncredited.' };
+      next_action: step.preflight_failure.code === 'FILE_HASH_TYPE'
+        ? 'The declared artifact is a directory or special file, which cannot be hashed as an artifact. Retrying the same path will fail again. Either redeclare the task (retire and redeclare its id) with a regular file as its artifact — for example a manifest file you write that lists the directory contents — or drop the artifact and assert over the directory with a Glob check in the task checks instead. The failed check remains uncredited.'
+        : 'Prepare the missing or invalid artifact with a new step or publish the preserved draft; then retry_call under current permissions. If the task is blocked, resume_call only changes its recorded status. The failed check remains uncredited.' };
   });
   return { plan: book.plan, scope: 'recorded_work_execution', asked: 'unjudged', counts: Object.fromEntries(['pending', 'in_progress', 'blocked', 'done', 'needs_verification'].map(status => [status, book.tasks.filter(task => task.status === status).length])), cards: book.tasks.map(summarize), current: next ? { ...summarize(next), criterion: next.criterion, checks: next.checks, capabilities: next.capabilities || [], artifacts: next.artifacts || [], definition_digest: next.definition_digest, work_digest: workDigest(next) } : null,
     recent_steps: book.steps.slice(-6).map(({ task_id, step_id, status, receipt_id, receipt_ref, operation, next_action, ref, preflight_failure, recovery_ref }) => ({ task_id, step_id, status, receipt_id, operation, next_action,
@@ -278,6 +314,7 @@ function projectWork(book) {
     drafts: book.drafts.map(({ id, task_id, file_path, digest, bytes, complete, parts, part_ids }) => ({ id, task_id, file_path, digest, bytes, complete, next_index: parts.length, recent_part_ids: (part_ids || []).slice(-3).filter(Boolean) })),
     checkpoint: book.checkpoint ? { reason: book.checkpoint.reason, plan_digest: book.checkpoint.plan_digest, task_id: book.checkpoint.task_id, next_action: book.checkpoint.next_action, ref: book.checkpoint.ref } : null,
     source_preflight_failures: book.steps.filter(step=>step.failure_closed?.kind==='native_file_pre_replacement_rejection').map(step=>({task_id:step.task_id,step_id:step.step_id,...step.failure_closed,next_action:'The native destination replacement was not dispatched. Preserve this failed step, inspect current source, and use a NEW step with its explicit expected version. Current permissions and checks still apply; do not replay the failed step ID.'})),
+    mcp_failures: book.steps.filter(step=>step.failure_closed?.kind==='mcp_error_result').map(step=>({task_id:step.task_id,step_id:step.step_id,...step.failure_closed,next_action:'The MCP server itself returned an error result for this step; that reply is the receipt. Effects stay unjudged: the server may have applied part of a mutating action, so inspect the page state (snapshot, console) before repeating one. A declared check runs again with the same step_id and recheck:true; any other step continues under a NEW step id.'})),
     process_failures: book.steps.filter(step=>step.failure_closed?.kind==='native_process_nonzero_exit').map(step=>({task_id:step.task_id,step_id:step.step_id,...step.failure_closed,next_action:'The shell ended with a nonzero exit. Preserve partial outputs and failed receipts; use a new judged correction step, then rerun mandatory checks. Do not replay the failed step ID.'})),
     media_preflight_failures: book.steps.filter(step=>step.failure_closed?.kind==='native_media_preflight_rejection').map(step=>({task_id:step.task_id,step_id:step.step_id,...step.failure_closed,next_action:'No provider media request was sent. Use a supported MIME in a new observation step; an image-only provider can inspect locally extracted video frames. Failed checks remain uncredited.'})),
     media_processing: book.steps.filter(step=>step.failure_closed?.kind==='native_media_processing_acknowledged').map(step=>({task_id:step.task_id,step_id:step.step_id,...step.failure_closed,next_action:'The media upload was acknowledged; no artifact candidate exists from this failed attempt. Preserve its ID and failed receipt. Reconcile the SAME directory/metadata in a new judged ArtifactPublish step; do not replay this failed step ID or invent an artifact ID.'})),
@@ -290,12 +327,25 @@ function projectWork(book) {
 }
 
 export class WorkCoordinator {
-  constructor({ store, house, onEvent = () => {} }) { Object.assign(this, { store, house, onEvent }); }
+  // closeGuards: async ({task, checks:[{check, receipt}], sessionId}) => void; a throw refuses the close.
+  constructor({ store, house, onEvent = () => {}, closeGuards = [] }) { Object.assign(this, { store, house, onEvent, closeGuards }); }
   async notify(sessionId) { await this.onEvent({ type: 'work_board', session_id: sessionId, board: workProjection(await this.store.load(sessionId), this.house.stateContext()) }); }
   async mutate(sessionId, action) { return this.store.workTransaction(sessionId, async () => { const session = await this.store.load(sessionId); if (!session.journalAudit.consistent) throw failure('El libro no tiene una cadena consistente.', 'AUDIT_INVALID'); return action(session, foldWorkBook(session, this.house.stateContext())); }); }
-  task(book, input) {
+  task(book, input, tool = null) {
     if (!book.plan || input.plan_version !== book.plan.version) throw failure(`Versión de plan obsoleta: requiere plan_version:${book.plan?.version || 0}. Continúa el borrador/tarea con esa precondición; la versión vigente está en este resultado, no necesitas WorkBoard.`);
-    const task = book.tasks.find(task => task.id === input.task_id); if (!task) throw failure('Tarea inexistente.'); return task;
+    const task = book.tasks.find(task => task.id === input.task_id); if (task) return task;
+    // Gate OR-8: «Tarea inexistente.» a secas dejaba al modelo sin salida (no_progress). Se dice qué falta,
+    // qué tareas siguen abiertas y, con una sola en curso, la llamada exacta (recovery_call: una respuesta de gracia).
+    const open = book.tasks.filter(item => item.status !== 'done').map(item => ({ id: item.id, status: item.status }));
+    const running = book.tasks.filter(item => item.status === 'in_progress');
+    // Solo donde la llamada corregida no puede cambiar otra tarea (WorkTaskUpdate cambiaría el estado de la que
+    // está en curso). El content no se repite: un rechazo de más de 16384 caracteres se pagina y la gracia se pierde.
+    const offer = ['WorkDraft', 'WorkStepRun'].includes(tool) && running.length === 1;
+    const { content, ...rest } = input;
+    const hint = { code: 'WORK_TASK_UNKNOWN', executed: false, given: input.task_id ?? null, open_tasks: open,
+      ...(offer ? { recovery_call: { name: tool, input: { ...rest, task_id: running[0].id }, ...(content !== undefined ? { resend_from_previous_call: ['content'] } : {}) },
+        next_action: `Repite la misma llamada con task_id:${running[0].id}` + (content !== undefined ? ' y el mismo content.' : '.') } : {}) };
+    throw failure((input.task_id == null ? 'Falta task_id. ' : `Tarea inexistente: ${input.task_id}. `) + JSON.stringify(hint), 'WORK_TASK_UNKNOWN');
   }
   async fact(options, row) { await options.recordWork({ ...row, source: 'work_host' }); }
   async setPlan(input, options) {
@@ -305,7 +355,14 @@ export class WorkCoordinator {
         ? `Plan cambiado: versión vigente ${expected}; WorkPlanSet requiere expected_version:${expected}. Conserva las tareas abiertas o declara retiros explícitos. El estado ya está en la proyección.`
         : 'No existe plan aceptado. Para crear el primer plan usa WorkPlanSet con expected_version:0 y una tarea pequeña. La versión 1 será el resultado, no la precondición. No necesitas consultar WorkBoard.');
       if (Buffer.byteLength(JSON.stringify(input)) > 64000) throw failure('Plan demasiado grande: usa tareas más pequeñas.');
-      const proposed = input.append ? [...book.tasks.map(definitionOf), ...input.tasks] : input.tasks;
+      const retiring = new Set(input.retire_ids || []), unknownRetired = [...retiring].filter(id => !book.tasks.some(task => task.id === id));
+      if (unknownRetired.length) throw failure(`retire_ids nombra tareas que no están en el plan: ${unknownRetired.join(', ')}. Usa los ids de la proyección.`, 'WORK_PLAN_INPUT');
+      // Un paso que espera permiso humano lo frena la casa antes del efecto (WORK_STALE); uno en curso o interrumpido no.
+      for (const task of book.tasks.filter(task => retiring.has(task.id))) {
+        if (book.steps.some(step => step.task_id === task.id && (step.status === 'interrupted' || step.status === 'running' && !task.held_by?.includes('human_permission') || step.status === 'failed' && !step.failure_closed && !readOnlyWorkCheck(step.operation, step.arguments)))) throw failure(`La tarea ${task.id} tiene un paso con efectos inciertos; inspecciona y ciérralo antes de retirarla (retirarla borraría ese estado del tablero).`, 'WORK_UNCERTAIN');
+      }
+      // append conserva las tareas anteriores salvo las retiradas.
+      const proposed = input.append ? [...book.tasks.filter(task => !retiring.has(task.id)).map(definitionOf), ...input.tasks] : input.tasks;
       if (proposed.length > 24) throw failure('Máximo 24 tareas por plan, incluidas las conservadas.', 'WORK_PLAN_INPUT');
       const ids = new Set(proposed.map(task => task.id)); if (ids.size !== proposed.length) throw failure('IDs de tareas duplicados; append sólo admite IDs nuevos y conserva las tareas anteriores.', 'WORK_PLAN_INPUT');
       const definitions = proposed.map(task => ({ ...task, depends_on: task.depends_on || [], checks: task.checks || [] }));
@@ -313,14 +370,18 @@ export class WorkCoordinator {
       if (contractIssues.length) throw failure('Checks inválidos; el plan no se guardó. ' + (book.plan ? 'Para observaciones adicionales de DOM/consola/red NO hace falta reemplazar el plan: usa WorkStepRun con task_id vigente, plan_version:'+book.plan.version+', step_id NUEVO, operation y arguments. ' : '') + JSON.stringify({issues:contractIssues,available_operation_names:(options.catalogue || []).map(item=>item.name).filter(name=>!WORK_NAMES.includes(name)).slice(0,60),next_action:'Use an exact offered operation and its arguments; Read uses file_path. Preserve the requested artifacts and task criterion. No checks executed and no plan saved.'}), 'WORK_CHECK_CONTRACT');
       for (const task of definitions) {
         for (const check of task.checks) validateAssertions(check.assertions);
-        if (task.phase === 'verification' && (!task.checks.length || task.checks.some(check => !check.assertions?.length))) throw failure('Una tarea verification requiere aserciones explícitas en cada check.', 'WORK_ASSERTION');
+        if (task.phase === 'verification' && (!task.checks.length || task.checks.some(check => !check.assertions?.length))) {
+          // Gate OR-9: sin decir qué check ni cómo, el modelo encadenó planes rechazados hasta no_progress.
+          const missing = task.checks.filter(check => !check.assertions?.length).map(check => `${task.id}/${check.step_id}`);
+          throw failure(`Una tarea verification requiere aserciones explícitas en cada check. ${task.checks.length ? 'Sin aserciones: ' + missing.join(', ') + '.' : `${task.id} no tiene checks.`} Ejemplo: "assertions":[{"kind":"contains","value":"PASS"}] (kinds: nonempty, contains, not_contains, json_equals con pointer). Si la tarea solo lee, usa phase discovery.`, 'WORK_ASSERTION');
+        }
       }
       for (const task of definitions) { if (new Set(task.checks.map(check => check.step_id)).size !== task.checks.length) throw failure('IDs de comprobación duplicados.', 'WORK_PLAN_INPUT'); if (task.checks.some(check => Buffer.byteLength(JSON.stringify(check.arguments)) > 4000)) throw failure('Comprobación demasiado grande; declara una llamada pequeña.', 'WORK_PLAN_INPUT'); if (task.depends_on.some(parent => !ids.has(parent) || parent === task.id)) throw failure(`Dependencia inexistente o circular en ${task.id}: ${JSON.stringify(task.depends_on)}. Una tarea no depende de sí misma; IDs disponibles: ${[...ids].join(', ')}.`, 'WORK_PLAN_INPUT'); }
       const visiting = new Set(), visited = new Set();
       const visit = id => { if (visiting.has(id)) throw failure('Dependencias circulares.', 'WORK_PLAN_INPUT'); if (visited.has(id)) return; visiting.add(id); definitions.find(task => task.id === id).depends_on.forEach(visit); visiting.delete(id); visited.add(id); }; ids.forEach(visit);
       definitions.forEach(task => { task.definition_digest = digest(task); const old = book.tasks.find(old => old.id === task.id); if (old?.definition_digest === task.definition_digest && old.work_digest) task.work_digest = old.work_digest; });
       for (const old of book.tasks.filter(task => task.status !== 'done' && task.phase === 'verification' && task.checks.some(isMcpCheck))) if (!definitions.some(task => task.phase === 'verification' && task.checks.some(check => isMcpCheck(check) && old.checks.some(before => mcpServer(before) === mcpServer(check))))) throw failure('La verificación MCP declarada debe conservar checks MCP; Read/wc no sustituyen la etapa de navegador.', 'WORK_VERIFICATION_REQUIRED');
-      for (const old of book.tasks.filter(task => task.status !== 'done')) if (!definitions.some(task => task.id === old.id && task.definition_digest === old.definition_digest) && !(input.retire_ids || []).includes(old.id)) throw failure(`La tarea abierta ${old.id} no puede desaparecer: para corregir sólo checks usa WorkCheckRepair y conserva el borrador; para cambiar el encargo preserva su definición o declara retire_ids y reason.`);
+      for (const old of book.tasks.filter(task => task.status !== 'done')) if (!definitions.some(task => task.id === old.id && task.definition_digest === old.definition_digest) && !(input.retire_ids || []).includes(old.id)) { const readable = old.checks.length && old.checks.every(check => readOnlyWorkCheck(check.operation, check.arguments)); if (readable) throw failure(`La tarea abierta ${old.id} no puede desaparecer: para corregir sólo los argumentos de checks existentes usa WorkCheckRepair y conserva el borrador; para añadir checks o cambiar el encargo, retírala y redeclárala con el MISMO id en la misma llamada (append:true, retire_ids y reason); así sus dependientes siguen válidos.`); throw failure(`La tarea abierta ${old.id} no puede desaparecer y sus checks (MCP u otros efectos opacos) no se reparan con la casa: conserva su definición tal cual, o retírala y declara una tarea nueva con los checks corregidos. `+JSON.stringify({ retire_example: { retire_ids: [old.id], reason: 'Sustituida por una tarea con checks corregidos.' } }), 'WORK_PLAN_INPUT'); }
       if (input.retire_ids?.length && !input.reason?.trim()) throw failure('Retirar tareas requiere reason.');
       const planDigest = digest({ objective: input.objective, tasks: definitions });
       if (book.plan?.digest === planDigest) return { version: book.plan.version, plan_digest: planDigest, unchanged: true };
@@ -399,11 +460,11 @@ export class WorkCoordinator {
     if (input.verify) {
       if (input.status !== 'done') throw failure('verify sólo corresponde al cierre de una tarea.');
       const loaded = await this.store.load(options.sessionId);
-      let book = foldWorkBook(loaded, this.house.stateContext()), task = this.task(book, input);
+      let book = foldWorkBook(loaded, this.house.stateContext()), task = this.task(book, input, 'WorkTaskUpdate');
       if (task.declared_status !== 'in_progress' || task.held_by.some(id => book.tasks.find(parent => parent.id === id)?.declared_status !== 'done')) {
         const finish = workProjection(loaded,this.house.stateContext())?.finish_call;
         if (finish && task.declared_status === 'done') throw failure(JSON.stringify({code:'WORK_FINISH_REQUIRED',executed:false,direct_call:finish,next_action:'Invoke this active task finish call directly. It refreshes stale closed parents without reopening them.'}),'WORK_FINISH_REQUIRED');
-        throw failure('Activa una tarea sin dependencias pendientes antes de verificar.');
+        throw failure('Activa una tarea sin dependencias pendientes antes de verificar. '+JSON.stringify(inactiveTaskHint(book, task)), 'WORK_TASK_INACTIVE');
       }
       const refresh = async taskId => {
         const latest = foldWorkBook(await this.store.load(options.sessionId), this.house.stateContext()), old = this.task(latest, { task_id: taskId, plan_version: input.plan_version });
@@ -416,19 +477,19 @@ export class WorkCoordinator {
         } catch (error) { throw failure(`El check de la tarea cerrada ${old.id} perdió vigencia: ${error.message}. Repara la superficie antes de cerrar ${input.task_id}.`, error.code || 'WORK_UNVERIFIED'); }
       };
       for (const old of book.tasks.filter(old => old.id !== task.id && old.declared_status === 'done')) await refresh(old.id);
-      book = foldWorkBook(await this.store.load(options.sessionId), this.house.stateContext()); task = this.task(book, input);
-      if (task.status !== 'in_progress' || task.held_by.length) throw failure('Activa una tarea sin dependencias pendientes antes de verificar.');
+      book = foldWorkBook(await this.store.load(options.sessionId), this.house.stateContext()); task = this.task(book, input, 'WorkTaskUpdate');
+      if (task.status !== 'in_progress' || task.held_by.length) throw failure('Activa una tarea sin dependencias pendientes antes de verificar. '+JSON.stringify(inactiveTaskHint(book, task)), 'WORK_TASK_INACTIVE');
       for (const check of task.checks) {
         const step = book.steps.find(step => step.task_id === task.id && step.step_id === check.step_id);
         const receipt = book.receipts.get(step?.receipt_id);
         const staleDependency = receipt && task.depends_on.some(parent => receipt.evidence_row <= book.tasks.find(row => row.id === parent).ref);
         if (book.checkValid(task, check, step) && !staleDependency) continue;
-        if (!readOnlyWorkCheck(check.operation, check.arguments)) throw failure(`Check ${check.step_id} requiere WorkStepRun explícito; verify no repite efectos opacos.`, 'WORK_UNCERTAIN');
+        if (!readOnlyWorkCheck(check.operation, check.arguments)) throw failure(`Check ${check.step_id} requiere WorkStepRun explícito; verify no repite efectos opacos. `+retryHint(task, check, input.plan_version, book), 'WORK_UNCERTAIN');
         await this.runStep({ task_id: task.id, plan_version: input.plan_version, step_id: check.step_id, recheck: true }, options);
       }
     }
     const result = await this.mutate(options.sessionId, async (_, book) => {
-      const task = this.task(book, input); let receiptIds = []; const dependencyProofs = {};
+      const task = this.task(book, input, 'WorkTaskUpdate'); let receiptIds = []; const dependencyProofs = {};
       if (input.status === 'in_progress') {
         if (task.status === 'done') throw failure('Una tarea cerrada no se reabre por accidente; declara un nuevo plan para trabajo nuevo.');
         if (task.held_by.length) throw failure('Dependencias sin cerrar.');
@@ -437,12 +498,17 @@ export class WorkCoordinator {
       if (input.status === 'blocked' && !input.reason?.trim()) throw failure('Un bloqueo requiere reason.');
       if (input.status === 'done') {
         if (task.held_by.length || !task.checks.length) throw failure('Cierre requiere dependencias cerradas y comprobaciones declaradas.', 'WORK_UNVERIFIED');
+        const verifiedChecks = [];
         for (const check of task.checks) {
           const step = book.steps.find(step => step.task_id === task.id && step.task_digest === workDigest(task) && step.step_id === check.step_id && step.operation === check.operation && step.arguments_digest === digest(check.arguments));
           const receipt = book.receipts.get(step?.receipt_id);
           if (receipt && task.depends_on.some(parent => receipt.evidence_row <= book.tasks.find(row => row.id === parent).ref)) throw failure('La comprobación precede al cierre de una dependencia; usa recheck:true.', 'WORK_UNVERIFIED');
-          if (!book.checkValid(task, check, step)) throw failure(`Comprobación ${check.step_id} sin recibo vigente o aserción satisfecha de la casa.`, 'WORK_UNVERIFIED');
-          receiptIds.push(receipt.invocation_id);
+          if (!book.checkValid(task, check, step)) throw failure(`Comprobación ${check.step_id} sin recibo vigente o aserción satisfecha de la casa. `+retryHint(task, check, book.plan.version, book), 'WORK_UNVERIFIED');
+          receiptIds.push(receipt.invocation_id); verifiedChecks.push({ check, receipt });
+        }
+        for (const guard of this.closeGuards) {
+          try { await guard({ task, checks: verifiedChecks, receipts: [...book.receipts.values()], sessionId: options.sessionId }); }
+          catch (error) { throw error.required_check ? withRequiredCheckRecovery(error, task, book) : error; }
         }
         const artifacts = new Map();
         const candidates = book.steps.filter(step => step.task_id === task.id && step.status === 'returned').map(step => book.receipts.get(step.receipt_id));
@@ -457,7 +523,7 @@ export class WorkCoordinator {
         for (const [file, receipt] of artifacts) { if (!book.receiptValid(receipt)) throw failure(`Un artefacto de la tarea cambió después de su observación: ${file}. Verifica los bytes actuales mediante un check declarado con artifacts o WorkStepRun Read nuevo; no restaures versiones antiguas.`, 'WORK_UNVERIFIED'); receiptIds.push(receipt.invocation_id); }
         receiptIds = [...new Set(receiptIds)];
         for (const parent of task.depends_on) dependencyProofs[parent] = digest(book.tasks.find(row => row.id === parent).receipt_ids);
-        if (book.steps.some(step => step.task_id === task.id && (['running', 'interrupted'].includes(step.status)||step.status==='failed'&&!step.failure_closed))) throw failure('Hay un paso con efectos inciertos: inspecciona antes de cerrar.', 'WORK_UNVERIFIED');
+        if (book.steps.some(step => step.task_id === task.id && (['running', 'interrupted'].includes(step.status)||step.status==='failed'&&!step.failure_closed&&!readOnlyWorkCheck(step.operation, step.arguments)))) throw failure('Hay un paso con efectos inciertos: inspecciona antes de cerrar.', 'WORK_UNVERIFIED');
       }
       // Artifact/check reads above can yield to external changes. Recheck the
       // original authority and close guards at the final durable done frontier.
@@ -478,7 +544,7 @@ export class WorkCoordinator {
   async runStep(input, options) {
     if(!options.draftPublication)await this.fact(options,{type:'work_call_prepared',operation:'WorkStepRun',input});
     if (input.operation === undefined || input.arguments === undefined) {
-      const book = foldWorkBook(await this.store.load(options.sessionId), this.house.stateContext()), task = this.task(book, input), check = task.checks.find(check => check.step_id === input.step_id);
+      const book = foldWorkBook(await this.store.load(options.sessionId), this.house.stateContext()), task = this.task(book, input, 'WorkStepRun'), check = task.checks.find(check => check.step_id === input.step_id);
       if (!check) throw failure('Un paso nuevo requiere operation y arguments; para checks basta su step_id.');
       input = { ...input, operation: input.operation ?? check.operation, arguments: input.arguments ?? check.arguments };
     }
@@ -488,22 +554,35 @@ export class WorkCoordinator {
       throw failure(JSON.stringify({code:'WORK_CONTROL_DIRECT',executed:false,direct_call:{name:input.operation,input:input.operation==='WorkCheckRepair'?{plan_version:version}:input.arguments},next_action:'Invoke direct_call as a TOP-LEVEL tool call, never inside WorkStepRun. No step was reserved and no effect executed.'}), 'WORK_CONTROL_DIRECT');
     }
     const staged = await this.mutate(options.sessionId, async (session, book) => {
-      const task = this.task(book, input);
+      const task = this.task(book, input, 'WorkStepRun');
       const check = task.checks.find(check => check.step_id === input.step_id);
       const refresh = options.refreshCompleted && task.declared_status === 'done' && check && readOnlyWorkCheck(check.operation, check.arguments);
       if ((!refresh && task.status !== 'in_progress') || task.held_by.length) {
         const finish = workProjection(session,this.house.stateContext())?.finish_call;
         if (finish?.input.task_id === task.id) throw failure(JSON.stringify({code:'WORK_FINISH_REQUIRED',executed:false,direct_call:finish,next_action:'Use this TOP-LEVEL finish call; the house refreshes already closed read dependencies before checking this task. No step was reserved.'}),'WORK_FINISH_REQUIRED');
-        throw failure('Activa una tarea sin dependencias pendientes antes de ejecutar.');
+        throw failure('Activa una tarea sin dependencias pendientes antes de ejecutar. '+JSON.stringify(inactiveTaskHint(book, task)), 'WORK_TASK_INACTIVE');
       }
       if (input.recheck && !check) throw failure('recheck sólo corresponde a una comprobación declarada.');
-      if (check && (check.operation !== input.operation || digest(check.arguments) !== digest(input.arguments))) throw failure('La comprobación propuesta no coincide con el plan. No se cambió nada. '+JSON.stringify({expected_check:check,check_call:{name:'WorkStepRun',input:{task_id:task.id,plan_version:book.plan.version,step_id:check.step_id}},observation_hint:'Para una observación distinta usa otro step_id NUEVO con operation y arguments explícitos; adquiere su pack antes. No reemplaces el plan ni reutilices el ID de este check.'}),'WORK_CHECK_MISMATCH');
+      if (check && (check.operation !== input.operation || digest(check.arguments) !== digest(input.arguments))) {
+        // Same operation, new arguments: the declared check itself may be wrong (it cannot pass as written).
+        // WorkCheckRepair is the path that keeps assertions and refuses checks with recorded effects; offer
+        // its exact call instead of leaving the model between "new step_id" and "do not replace the plan".
+        // Offer it only where WorkCheckRepair accepts it: a check not run yet (no recorded step whose
+        // receipts a repair would have to retire) and outside the runtime-ID-only rule for read checks.
+        const ranBefore = book.steps.some(step => step.task_id === task.id && step.step_id === check.step_id);
+        const runtimeOnly = readOnlyWorkCheck(check.operation, check.arguments) && task.checks.some(item => runtimeBoundReadCheck(item.operation, item.arguments));
+        const repairable = input.operation === check.operation && input.arguments !== undefined && !ranBefore && !runtimeOnly;
+        const recovery = repairable ? { recovery_call: { name: 'WorkCheckRepair', input: { plan_version: book.plan.version, repairs: [{ task_id: task.id, step_id: check.step_id, expected_digest: digest(check), operation: input.operation, arguments: input.arguments }], reason: 'The declared check cannot pass as written; repair its arguments, keeping its assertions.' } } } : {};
+        throw failure('La comprobación propuesta no coincide con el plan. No se cambió nada. '+JSON.stringify({expected_check:check,check_call:{name:'WorkStepRun',input:{task_id:task.id,plan_version:book.plan.version,step_id:check.step_id}},...recovery,observation_hint:(repairable?'Si el check declarado está mal escrito y no puede pasar tal cual, repáralo con recovery_call (WorkCheckRepair conserva sus aserciones) y luego corre check_call con el plan_version nuevo. ':'')+'Para una observación distinta usa otro step_id NUEVO con operation y arguments explícitos; adquiere su pack antes. No reemplaces el plan entero ni reutilices el ID de este check para otra cosa.'}),'WORK_CHECK_MISMATCH');
+      }
       const existing = book.steps.find(step => step.task_id === task.id && step.step_id === input.step_id);
       if (existing) {
         if (existing.operation !== input.operation || existing.arguments_digest !== digest(input.arguments)) throw failure('El ID del paso ya nombra otros argumentos. '+JSON.stringify({code:'WORK_STEP_ID_CONFLICT',executed:false,step_id:existing.step_id,operation:existing.operation,arguments_digest:existing.arguments_digest,status:existing.status,receipt_id:existing.receipt_id,read_call:{name:'EvidenceRead',input:{row:existing.receipt_ref ?? existing.ref}},next_action:'Read the original record with read_call; do not repeat a completed effect. Only genuinely new work uses a new step_id.'}), 'WORK_STEP_ID_CONFLICT');
-        if (existing.status === 'returned' && !input.recheck) { const receipt = book.receipts.get(existing.receipt_id); if (check ? !book.checkValid(task, check, existing) : !book.receiptValid(receipt)) throw failure('El efecto registrado perdió vigencia o su aserción falló; usa recheck para un check, sin repetir mutaciones.', 'WORK_UNVERIFIED'); return { reuse: receipt }; }
+        if (existing.status === 'returned' && !input.recheck) { const receipt = book.receipts.get(existing.receipt_id); if (check ? !book.checkValid(task, check, existing) : !book.receiptValid(receipt)) throw failure('El efecto registrado perdió vigencia o su aserción falló; usa recheck para un check, sin repetir mutaciones.'+(check ? ' '+retryHint(task, check, book.plan.version) : ''), 'WORK_UNVERIFIED'); return { reuse: receipt }; }
         const retryFailedRead = input.recheck && check && existing.status === 'failed' && book.receipts.has(existing.receipt_id) && readOnlyWorkCheck(check.operation, check.arguments);
-        if (existing.status !== 'refused' && !(input.recheck && check && existing.status === 'returned') && !retryFailedRead) throw failure('El paso quedó interrumpido o falló con posibles efectos; inspecciona y registra otro paso antes de repetir. Un check de lectura con recibo failed se recupera con el mismo step_id y recheck:true.', 'WORK_UNCERTAIN');
+        // A declared MCP check whose server answered with an error result is closed: it runs again with recheck.
+        const retryClosedMcp = input.recheck && check && existing.status === 'failed' && existing.failure_closed?.kind === 'mcp_error_result';
+        if (existing.status !== 'refused' && !(input.recheck && check && existing.status === 'returned') && !retryFailedRead && !retryClosedMcp) { const guide = check && effectfulGuide(book, task, check, book.plan.version); if (guide) throw failure('El check declarado no se repite. '+JSON.stringify(guide), 'WORK_UNCERTAIN'); throw failure('El paso quedó interrumpido o falló con posibles efectos; inspecciona y registra otro paso antes de repetir. Un check de lectura con recibo failed se recupera con el mismo step_id y recheck:true.', 'WORK_UNCERTAIN'); }
       }
       const incoming=this.house.registry.get(input.operation),pureObservation=readOnlyWorkCheck(input.operation,input.arguments)&&incoming?.contract.origin===null&&incoming.contract.effects.workspace==='read'&&incoming.contract.effects.external==='none'&&incoming.contract.effects.authority==='none'&&(incoming.contract.effects.process==='none'||input.operation==='GitInspect'&&incoming.contract.effects.process==='read'||input.operation==='Bash'&&Boolean(readOnlyWorkCheck('Bash',input.arguments)));
       if (!pureObservation&&book.steps.some(step => step.task_id === task.id && (['running', 'interrupted'].includes(step.status) || step.status === 'failed' && !step.failure_closed && !readOnlyWorkCheck(step.operation, step.arguments)))) throw failure('The task has uncertain effects. New mutations remain fenced. Native Read/FileInfo/ListDirectory/Grep observations may inspect current state; do not repeat the uncertain action.', 'WORK_UNCERTAIN');
@@ -559,14 +638,14 @@ export class WorkCoordinator {
   async draft(input, options) {
     await this.fact(options,{type:'work_call_prepared',operation:'WorkDraft',input});
     if (input.action === 'read' || input.action === 'publish') {
-      const book = foldWorkBook(await this.store.load(options.sessionId)), task = this.task(book, input), draft = book.drafts.find(draft => draft.task_id === task.id && draft.id === input.draft_id);
+      const book = foldWorkBook(await this.store.load(options.sessionId)), task = this.task(book, input, 'WorkDraft'), draft = book.drafts.find(draft => draft.task_id === task.id && draft.id === input.draft_id);
       if (!draft) throw failure('Borrador inexistente.');
       if (input.action === 'read') { const content = draft.parts.join(''), offset = input.offset || 0, limit = input.limit || 4000; return JSON.stringify({ draft_id: draft.id, digest: draft.digest, complete: draft.complete, content: content.slice(offset, offset + limit), ...(offset + limit < content.length ? { next_offset: offset + limit } : {}), bytes: draft.bytes }); }
       if (!draft.complete || input.expected_digest !== undefined && input.expected_digest !== draft.digest) throw failure('No se publica un borrador incompleto o con digest obsoleto.');
       return this.runStep({ ...input, step_id: `publish:${draft.id}:${draft.digest.slice(0, 12)}`, operation: 'Write', arguments: { file_path: draft.file_path, content: draft.parts.join('') }, next_action: input.next_action || 'Run the declared checks on the published artifact.' }, { ...options, draftPublication: true });
     }
     const result = await this.mutate(options.sessionId, async (_, book) => {
-      const task = this.task(book, input); if (task.status === 'done') throw failure('La tarea ya está cerrada.');
+      const task = this.task(book, input, 'WorkDraft'); if (task.status === 'done') throw failure('La tarea ya está cerrada.');
       if (input.content === undefined || !input.file_path || input.action === 'chunk' && input.index === undefined || input.action === 'append' && !input.part_id) throw failure('append requiere part_id, content y file_path; chunk requiere index, content y file_path.');
       if (book.drafts.filter(draft => draft.task_id === task.id).length >= 32 && !book.drafts.some(draft => draft.task_id === task.id && draft.id === input.draft_id)) throw failure('Máximo 32 borradores por tarea; divide el trabajo.');
       const draft = book.drafts.find(draft => draft.task_id === task.id && draft.id === input.draft_id), parts = draft?.parts || [];
@@ -584,7 +663,7 @@ export class WorkCoordinator {
     const task = { task_id: id, plan_version: version };
     return [
       {name:'WorkFailureReview',description:'Local operator attests review of an exact terminal native Bash failure after inspecting partial state. Keeps failure, mandatory checks and no replay. This is NOT objective execution success or human task acceptance.',audience:'human',surfaces:['cli','tui'],permission:null,effects:{workspace:'none',external:'none',process:'none',authority:'work_failure_review'},input_schema:schema({...task,step_id:id,expected_receipt:{type:'string',format:'uuid'},reason:{type:'string',minLength:20,maxLength:1000}},['task_id','plan_version','step_id','expected_receipt','reason']),run:(input,options)=>this.reviewFailure(input,options)},
-      { name: 'WorkPlanSet', description: 'Plan small tasks before effects; each needs id/title/criterion/checks. Up to 32 artifact files. Checks use exact tools, e.g. Read:{file_path:"file"}. Checks need complete, observed arguments: never invent a target_id. For discovery/implementation, declare a source Read check with a nonempty assertion. Add a separate verification task after observing runtime IDs; an open task cannot be closed without checks or have checks added by repair. Verification phase requires assertions. append:true adds tasks without resending old ones; no permission grant.', input_schema: schema({ objective: str(2200), expected_version: version, append: { type: 'boolean' }, tasks: { type: 'array', minItems: 1, maxItems: 24, items: schema({ id, title: str(300), criterion: str(1000), phase: { type: 'string', enum: ['discovery','implementation','verification'] }, capabilities: { type: 'array', maxItems: 4, uniqueItems: true, items: str(100) }, artifacts: { type: 'array', maxItems: 32, uniqueItems: true, items: str(1024) }, depends_on: { type: 'array', maxItems: 24, items: id }, checks: { type: 'array', maxItems: 4, items: schema({ step_id: id, operation: { ...str(128), description: 'Exact callable tool name from the catalogue, never an instruction or test description.' }, arguments: args, assertions: { type: 'array', minItems: 1, maxItems: 4, items: assertionSchema } }, ['step_id', 'operation', 'arguments']) } }, ['id', 'title', 'criterion', 'checks']) }, retire_ids: { type: 'array', maxItems: 24, items: id }, reason: str(1000) }, ['objective', 'expected_version', 'tasks']), run: (input, options) => this.setPlan(input, options) },
+      { name: 'WorkPlanSet', description: 'Plan small tasks before effects; each needs id/title/criterion/checks. Up to 32 artifact files. Checks use exact tools, e.g. Read:{file_path:"file"}. Checks need complete, observed arguments: never invent a target_id. For discovery/implementation, declare a source Read check with a nonempty assertion. Add a separate verification task after observing runtime IDs; an open task cannot be closed without checks or have checks added by repair. Verification phase requires assertions. append:true adds tasks without resending old ones; no permission grant.', input_schema: schema({ objective: str(2200), expected_version: version, append: { type: 'boolean' }, tasks: { type: 'array', minItems: 1, maxItems: 24, items: schema({ id, title: str(300), criterion: str(1000), phase: { type: 'string', enum: ['discovery','implementation','verification'] }, capabilities: { type: 'array', maxItems: 4, uniqueItems: true, items: str(100) }, artifacts: { type: 'array', maxItems: 32, uniqueItems: true, items: str(1024) }, depends_on: { type: 'array', maxItems: 24, items: id }, checks: { type: 'array', maxItems: MAX_TASK_CHECKS, items: schema({ step_id: id, operation: { ...str(128), description: 'Exact callable tool name from the catalogue, never an instruction or test description.' }, arguments: args, assertions: { type: 'array', minItems: 1, maxItems: 4, items: assertionSchema } }, ['step_id', 'operation', 'arguments']) } }, ['id', 'title', 'criterion', 'checks']) }, retire_ids: { type: 'array', maxItems: 24, items: id }, reason: str(1000) }, ['objective', 'expected_version', 'tasks']), run: (input, options) => this.setPlan(input, options) },
       { name: 'WorkCheckRepair', description: 'Repair check contracts locally without replacing tasks, retiring drafts or replaying effects. Supply current plan_version only for deterministic suggestions (Read/Grep keys, integer types, unique canonical MCP names). Optional repairs use exact check digests. Assertions/criteria/artifacts stay unchanged. Missing MCP: acquire browser.verify then retry. No permission grant.', input_schema: schema({ plan_version: version, literal_types_only: { type: 'boolean' }, repairs: { type: 'array', minItems: 1, maxItems: 8, items: schema({task_id:id,step_id:id,expected_digest:{type:'string',pattern:'^[a-f0-9]{64}$'},operation:str(128),arguments:args},['task_id','step_id','expected_digest']) }, reason:str(1000) }, ['plan_version']), run: (input,options) => this.repairChecks(input,options) },
       { name: 'WorkTaskUpdate', description: 'Start/block/close a task. done with verify:true runs missing/stale read-only checks from the plan through the judge, then closes. No model roundtrip per check. Opaque/mutating checks require explicit WorkStepRun. Records declared checks, not semantic objective proof.', input_schema: schema({ ...task, status: { type: 'string', enum: ['in_progress', 'blocked', 'done'] }, verify: { type: 'boolean' }, reason: str(1000) }, ['task_id', 'plan_version', 'status']), run: (input, options) => this.updateTask(input, options) },
       { name: 'WorkStepRun', description: 'Call WorkCheckRepair, ToolPack and WorkTaskUpdate DIRECTLY, never nested here. Run a declared check OR additional work/observations through the judge. Declared check: existing step_id, omit operation/arguments. Additional observation (DOM, console, network, discovery) or implementation: NEW unique step_id plus exact operation and arguments; NO plan edit or check repair is needed. Extra steps do not change assertions. Do not rename existing checks. Retry failed read-only checks with SAME step_id and recheck:true; never repeat uncertain mutations. Completed steps reuse receipts.', input_schema: schema({ ...task, step_id: id, operation: str(128), arguments: args, next_action: str(1000), recheck: { type: 'boolean' } }, ['task_id', 'plan_version', 'step_id']), run: (input, options) => this.runStep(input, options) },
@@ -594,15 +673,72 @@ export class WorkCoordinator {
   }
 }
 
-export function registerWorkOperations({ store, house, onEvent, artifactObservation }) {
+// Por qué una tarea no está activa y cuál es la llamada siguiente (gate «extensión de bóveda»: con
+// «Activa una tarea…» a secas el modelo repitió WorkStepRun hasta no_progress).
+export function inactiveTaskHint(book, task) {
+  const byId = id => book.tasks.find(parent => parent.id === id);
+  const held = task.held_by || [];
+  // held_by sale del estado derivado: una dependencia cerrada que perdió vigencia sigue bloqueando.
+  const stale = held.filter(id => byId(id)?.declared_status === 'done' && byId(id)?.status !== 'done');
+  const pending = held.filter(id => byId(id) && byId(id).declared_status !== 'done');
+  const active = book.tasks.find(other => other.id !== task.id && other.declared_status === 'in_progress')?.id || null;
+  const base = { code: 'WORK_TASK_INACTIVE', executed: false, task_id: task.id, status: task.status, held_by: held, stale_parents: stale, active_task: active, next_call: null };
+  const replan = (ids, why) => ({ ...base, replan_call: { name: 'WorkPlanSet', input: { expected_version: book.plan.version } },
+    next_action: `${why} Una tarea cerrada no se reabre: declara un plan nuevo (WorkPlanSet con expected_version ${book.plan.version}) con una tarea que vuelva a hacer las comprobaciones de ${ids.join(', ')}.` });
+  if (task.declared_status === 'done' && task.status === 'needs_verification') return replan([task.id], `La tarea ${task.id} está cerrada y perdió vigencia.`);
+  if (task.declared_status === 'done' && task.status === 'done') return { ...base, next_action: `La tarea ${task.id} ya está cerrada y vigente: no hace falta activarla ni ejecutarla. Sigue con la siguiente tarea del plan.` };
+  if (stale.length) return replan(stale, `Sus dependencias ${stale.join(', ')} están cerradas pero perdieron vigencia.`);
+  if (pending.length) return { ...base, next_action: `Cierra antes sus dependencias: ${pending.join(', ')}.` };
+  if (held.includes('human_permission')) return { ...base, next_action: 'Espera la respuesta del humano a la autorización pendiente.' };
+  if (active) return { ...base, next_action: `Ya está activa ${active}: termínala o bloquéala antes de activar ${task.id}.` };
+  return { ...base, next_call: { name: 'WorkTaskUpdate', input: { task_id: task.id, plan_version: book.plan.version, status: 'in_progress' } }, next_action: `Activa ${task.id} con next_call y repite la llamada.` };
+}
+
+// La llamada exacta para volver a comprobar un check sin vigencia: el modelo la copia en vez de adivinar
+// (gate «extensión de bóveda»: con solo «usa recheck» probó WorkBoard y WorkTaskUpdate hasta no_progress).
+// Gate OR-9: un check con efectos cuyo paso ya falló no se repite (ni recheck ni reparación: duplicaría sus
+// efectos). Ofrecer el recheck dejaba al modelo en un bucle con la llamada que la casa rechaza; el camino que
+// existe es replantear: retirar la tarea con reason y declarar una nueva con el check bajo otro step_id.
+const replanGuide = (task, plan_version) => ({ code: 'WORK_CHECK_FAILED_EFFECTS', executed: false, task_id: task.id,
+  next_action: `El check falló con posibles efectos y no se repite (ni recheck ni WorkCheckRepair). Replantea con WorkPlanSet: expected_version:${plan_version}, append:true, el mismo objective, retire_ids:["${task.id}"] y reason, y una tarea nueva con el check bajo otro step_id (mejor de solo lectura: Read/Grep o un Bash sin escrituras; la evidencia, en un paso aparte).` });
+// Revisión independiente: con efectos inciertos (paso interrumpido o falla sin cierre) setPlan tampoco deja
+// retirar la tarea; lo único honesto es inspeccionar y pedir la revisión del operador.
+const operatorGuide = task => ({ code: 'WORK_CHECK_UNCERTAIN', executed: false, task_id: task.id,
+  next_action: 'El paso del check quedó con efectos inciertos (interrumpido o sin cierre de la casa): no se repite ni se puede retirar la tarea. Inspecciona el estado con Read y pide la revisión del operador (report_blocked o ask; WorkFailureReview es solo humano).' });
+// null: el recheck procede. 'closed': falló con final conocido (replantear). 'uncertain': efectos inciertos.
+function effectfulCheckState(book, task, check) {
+  if (readOnlyWorkCheck(check.operation, check.arguments)) return null;
+  const step = book.steps.find(step => step.task_id === task.id && step.step_id === check.step_id);
+  if (!step) return null;
+  if (['interrupted', 'running'].includes(step.status)) return 'uncertain';
+  if (step.status !== 'failed' || step.failure_closed?.kind === 'mcp_error_result') return null;
+  return step.failure_closed ? 'closed' : 'uncertain';
+}
+const effectfulGuide = (book, task, check, plan_version) => {
+  const state = effectfulCheckState(book, task, check);
+  return state === 'closed' ? replanGuide(task, plan_version) : state === 'uncertain' ? operatorGuide(task) : null;
+};
+function retryHint(task, check, plan_version, book = null) {
+  const guide = book && effectfulGuide(book, task, check, plan_version);
+  if (guide) return JSON.stringify(guide);
+  return JSON.stringify({ retry_call: { name: 'WorkStepRun', input: { task_id: task.id, plan_version, step_id: check.step_id, operation: check.operation, arguments: check.arguments, recheck: true } } });
+}
+
+const coordinators = new WeakMap();
+export function registerWorkOperations({ store, house, onEvent, artifactObservation, closeGuards }) {
   if (artifactObservation) {
     const { sessionId, operation } = artifactObservation;
     if (typeof sessionId !== 'string' || !['Read', 'FileInfo'].includes(operation)) throw failure('Invalid host artifact observer.');
     if (!artifactObservers.has(house)) artifactObservers.set(house, new Map());
     artifactObservers.get(house).set(sessionId, operation);
   }
-  const coordinator = new WorkCoordinator({ store, house, onEvent });
+  // The first coordinator owns the registered operations; later calls on the same
+  // house add their close guards to it instead of silently dropping them.
+  const coordinator = new WorkCoordinator({ store, house, onEvent, closeGuards: [...(closeGuards || [])] });
+  const owner = coordinators.get(house);
+  if (owner && house.registry.get('WorkTaskUpdate')) { owner.closeGuards.push(...(closeGuards || [])); return coordinator; }
   for (const definition of coordinator.operations()) if (!house.registry.get(definition.name)) house.registry.add(definition);
+  coordinators.set(house, coordinator);
   return coordinator;
 }
 

package/src/work-state.mjs

@@ -102,7 +102,7 @@ export function modelWorkState(session, options = {}) {
     }
   }
   const preferredPaths = (state.work?.current?.artifacts || []).map(file => path.resolve(session.cwd, file));
-  state.file_working_set = recordedFilePages(session, 24000, { preferredPaths });
+  state.file_working_set = recordedFilePages(session, options.files?.byteBudget ?? 24000, { preferredPaths, maxFiles: options.files?.maxFiles, preferEdited: options.files?.preferEdited });
   // Fold and validate the complete host state before projecting away its plan,
   // step history and identifiers. Long Chrome tasks also reach this path.
   if (state.workflow?.kind === 'chrome-task' && state.work) state.work = {
@@ -116,7 +116,7 @@ export function modelWorkState(session, options = {}) {
 
 // Reconstruct already-read pages, never fetch files or interpret model prose.
 // Hash currency is only the latest RECORDED observation, not a live disk claim.
-export function recordedFilePages(session, byteBudget = 24000, { preferredPaths = [] } = {}) {
+export function recordedFilePages(session, byteBudget = 24000, { preferredPaths = [], maxFiles = 4, preferEdited = false } = {}) {
   const audit = auditExecution(session), files = new Map(), argumentsByCall = new Map(), workArguments = new Map();
   const fileKey = (path, hash) => JSON.stringify([path, hash]);
   const textHash = text => createHash('sha256').update(text).digest('hex');
@@ -146,7 +146,7 @@ export function recordedFilePages(session, byteBudget = 24000, { preferredPaths
       }
       if (typeof content !== 'string' || textHash(content) !== write.after_sha256) continue;
       const lines = new Map(content.split('\n').map((line,index)=>[index+1,line]));
-      files.set(fileKey(write.file_path,write.after_sha256), {file_path:write.file_path,sha256:write.after_sha256,lines,pages:[{row:receipt.evidence_row,call_id:receipt.call_id,first:1,last:lines.size}],last:receipt.evidence_row});
+      files.set(fileKey(write.file_path,write.after_sha256), {file_path:write.file_path,sha256:write.after_sha256,lines,pages:[{row:receipt.evidence_row,call_id:receipt.call_id,first:1,last:lines.size}],last:receipt.evidence_row,edited:receipt.evidence_row});
       continue;
     }
     const read = receipt.observations?.find(observation => observation.kind === 'file_read');
@@ -162,7 +162,7 @@ export function recordedFilePages(session, byteBudget = 24000, { preferredPaths
   }
   let budget = byteBudget, backgroundBudget = 2000; const result = [];
   const preferred = new Set(preferredPaths);
-  for (const file of [...files.values()].filter(file=>audit.state.find(item=>item.path===file.file_path)?.sha256===file.sha256).sort((a,b) => Number(preferred.has(path.resolve(session.cwd, b.file_path))) - Number(preferred.has(path.resolve(session.cwd, a.file_path))) || b.last - a.last).slice(0, 4)) {
+  for (const file of [...files.values()].filter(file=>audit.state.find(item=>item.path===file.file_path)?.sha256===file.sha256).sort((a,b) => Number(preferred.has(path.resolve(session.cwd, b.file_path))) - Number(preferred.has(path.resolve(session.cwd, a.file_path))) || (preferEdited ? (b.edited ?? -1) - (a.edited ?? -1) : 0) || b.last - a.last).slice(0, maxFiles)) {
     const chosen = new Map(), background = preferred.size > 0 && !preferred.has(path.resolve(session.cwd, file.file_path));
     let available = background ? Math.min(budget, backgroundBudget) : budget;
     for (const page of file.pages.slice().reverse()) for (let line = page.first; line <= page.last; line++) {

package/src/workflows/chrome-task-adoption.mjs

@@ -8,7 +8,11 @@ import { isHumanIntentRecord } from '../trusted-context.mjs';
 const required = ['Deploy','Deployment','Open','Targets','Assert','Contexts','Interact','ReadDOM','Console'];
 const entryNames = new Set(['ChromeTask','Read','Glob','Grep','ListDirectory','FileInfo','WebSearch','WebFetch']);
 const fail = (message, code = 'CHROME_TASK_DECLARATION') => Object.assign(new Error(message), { code });
-const activeSkill = session => session.rows.some(row => row.type === 'skill_scope_started' && row.source === 'skill_host' && !session.rows.some(end => end.type === 'skill_scope_completed' && end.source === 'skill_host' && end.scope_id === row.scope_id));
+const activeSkill = session => session.rows.findLast(row => row.type === 'skill_scope_started' && row.source === 'skill_host' && !session.rows.some(end => end.type === 'skill_scope_completed' && end.source === 'skill_host' && end.scope_id === row.scope_id));
+const skillBlocksAdoption = session => {
+  const skill = activeSkill(session);
+  return Boolean(skill && (skill.manifest?.context !== 'inline' || skill.manifest?.allowed_tools !== undefined));
+};
 const declarationSchema = structuredClone(chromeTaskSchema);
 // Conversational declaration retains its historical popup defaults. A page-only
 // verifier is selected explicitly by the host at startup, never by model input.
@@ -48,7 +52,7 @@ export class ChromeTaskAdoption {
   async sync() {
     const session = await this.store.load(this.id());
     this.pendingDeclaration = !savedChromeTask(session) && session.rows.some(row => row.type === 'chrome_task_proposed' && row.source === 'workflow_host');
-    const available = this.available() && !savedChromeTask(session) && !workProjection(session) && !activeSkill(session);
+    const available = this.available() && !savedChromeTask(session) && !workProjection(session) && !skillBlocksAdoption(session);
     this.focused = Boolean(this.coordinated && available);
     if (!available) { this.house.registry.replace(['ChromeTask'], []); return; }
     const deploy = this.house.registry.get('plugin__chrome-lab__Deploy');
@@ -66,7 +70,7 @@ export class ChromeTaskAdoption {
         const session = await this.store.load(this.id());
         if (!session.journalAudit.verified) throw fail('Invalid session journal.', 'AUDIT_INVALID');
         if (!this.available()) throw fail('Chrome Lab is not active; load its configured plugin before declaring a task.');
-        if (activeSkill(session)) throw fail('Declare the coordinated task in the resident session before entering a temporary skill scope. No contract or tool scope changed.', 'CHROME_TASK_SCOPE');
+        if (skillBlocksAdoption(session)) throw fail('Only an unrestricted inline skill may declare a coordinated task in its resident session. No contract or tool scope changed.', 'CHROME_TASK_SCOPE');
         if (savedChromeTask(session) || workProjection(session)) throw fail('Existing work is preserved. Continue its contract; start a new session for a different Chrome task.');
         const task = normalizeTask({ directory: 'extension', popup: 'popup.html', ...input, project: 'comal-' + this.id().replaceAll('-', '').slice(0, 24) });
         this.house.registry.get('plugin__chrome-lab__Deploy').validate({ project: task.project, directory: task.directory });