@milpa/comal 0.2.7 → 0.2.8

package/src/work-plan.mjs

@@ -171,6 +171,77 @@ function closedArtifactProcessing(session,step,audit,active){
   return {kind:'native_media_processing_acknowledged',media_id:media[1],receipt_id:leaf.invocation_id,parent_receipt_id:parent.invocation_id,candidate_created:false,retry_authorized:false,derivation:'legacy_builtin_publisher_processing_result'};
 }
 
+// A step that failed on a plugin's broken promise, when that promise was then repaired in this session.
+// The plugin threw, so the house cannot close the failure by itself: it does not know whether the call had
+// an outside effect first. What closes it is narrow and read from sealed rows only:
+//   - the failed receipt is an operation of plugin P, run by this step;
+//   - a plugin_repair_accepted row for P was sealed after it (a repair that rolled back seals none);
+//   - a finding owned by P about that SAME call (the operation and the arguments of the failed receipt, as the
+//     reproduction's own receipt shows) was resolved repaired_in_run with that accepted row as proof.
+// The cost is stated, not hidden: effects of the failed call stay unjudged, and the step may run again.
+const PLUGIN_OPERATION = /^plugin__([a-z][a-z0-9]*(?:-[a-z0-9]+)*)__[A-Za-z][A-Za-z0-9_]*$/;
+const sealedRef = row => row?.audit && Number.isInteger(row.audit.sequence) && typeof row.audit.sha256 === 'string' ? { sequence: row.audit.sequence, sha256: row.audit.sha256 } : null;
+const sameRef = (row, ref) => Boolean(sealedRef(row)) && Boolean(ref) && row.audit.sequence === ref.sequence && row.audit.sha256 === ref.sha256;
+function repairProof(rows, step, acceptedRef) {
+  const plugin = PLUGIN_OPERATION.exec(step.operation || '')?.[1];
+  if (!plugin || step.status !== 'failed' || !step.receipt_id) return null;
+  const failedAt = rows.findIndex(row => row.type === 'house_receipt' && row.invocation_id === step.receipt_id), failed = rows[failedAt];
+  if (!failed || failed.status !== 'failed' || failed.operation !== step.operation || failed.parent_invocation_id !== step.invocation_id || !sealedRef(failed)) return null;
+  const acceptedAt = rows.findIndex(row => row.type === 'plugin_repair_accepted' && row.source === 'plugin_repair' && row.plugin === plugin && sameRef(row, acceptedRef));
+  if (acceptedAt <= failedAt) return null;
+  for (let index = acceptedAt + 1; index < rows.length; index++) {
+    const resolution = rows[index];
+    if (resolution.type !== 'finding_resolution' || resolution.state !== 'repaired_in_run' || !sameRef(rows[acceptedAt], resolution.proof?.accepted)) continue;
+    const finding = rows.find(row => row.type === 'finding' && row.id === resolution.finding_id && row.owner === `plugin:${plugin}` && row.where?.operation === step.operation);
+    // The repaired case must be the very call that failed: the receipt of its reproduction (the finding's
+    // evidence) carries the same arguments as the step's failed receipt. Another call of the same operation
+    // proves nothing about this one.
+    const sameCall = finding && typeof failed.arguments_digest === 'string' && (finding.evidence ?? []).some(item => rows.some(row => row.type === 'house_receipt' && sameRef(row, item) && row.operation === step.operation && row.arguments_digest === failed.arguments_digest));
+    if (sameCall) return { plugin, operation: step.operation, failed_receipt: { invocation_id: failed.invocation_id, ...sealedRef(failed) }, accepted: sealedRef(rows[acceptedAt]), accepted_at: acceptedAt, finding: finding.id };
+  }
+  return null;
+}
+function closedPluginRepair(session, step, audit, active) {
+  if (step.status !== 'failed' || active.has(step.invocation_id) || !audit.journal.verified || audit.violations.length || audit.unverified.length) return null;
+  const rows = session.rows;
+  for (let index = rows.length - 1; index >= 0; index--) {
+    const row = rows[index];
+    if (row.type !== 'work_fence_released' || row.source !== 'work_host' || row.task_id !== step.task_id || row.step_id !== step.step_id || row.attempt_id !== step.attempt_id || row.task_digest !== step.task_digest) continue;
+    const proof = repairProof(rows, step, row.accepted);
+    if (!proof || index <= proof.accepted_at || row.plugin !== proof.plugin || row.failed_receipt?.invocation_id !== proof.failed_receipt.invocation_id || row.failed_receipt.sequence !== proof.failed_receipt.sequence || row.failed_receipt.sha256 !== proof.failed_receipt.sha256) continue;
+    return { kind: 'plugin_repaired_in_run', receipt_id: proof.failed_receipt.invocation_id, plugin: proof.plugin, accepted: proof.accepted, finding: proof.finding, release_ref: index, partial_effects: 'preserved_unjudged', external_effects: 'unjudged', retry_authorized: true };
+  }
+  return null;
+}
+/**
+ * After the house accepted a repair of `plugin` (the sealed plugin_repair_accepted row `accepted`: { sequence,
+ * sha256 }): every step that stays fenced because it failed on the very call that repair reproduced (the same operation
+ * with the same arguments) is released,
+ * each with a sealed work_fence_released row naming the task, the step, the failed receipt and the accepted
+ * row. Returns the steps the fold now reads as released: [{ task_id, step_id, operation }]. Nothing else is
+ * touched: another operation, another call of that operation, another plugin, or a step that is not a plugin
+ * operation stay fenced.
+ */
+export async function releaseRepairedSteps({ store, house, sessionId, plugin, accepted, invocation_id }) {
+  const context = () => house?.stateContext?.() ?? {};
+  const release = async () => {
+    const session = await store.load(sessionId);
+    if (!session.journalAudit.consistent) return [];
+    const wrote = [];
+    for (const step of foldWorkBook(session, context()).steps) {
+      if (step.status !== 'failed' || step.failure_closed) continue;
+      const proof = repairProof(session.rows, step, accepted);
+      if (!proof || proof.plugin !== plugin) continue;
+      await store.append(sessionId, { type: 'work_fence_released', source: 'work_host', reason: 'plugin_repaired_in_run', ...(invocation_id ? { invocation_id } : {}), task_id: step.task_id, task_digest: step.task_digest, plan_version: step.plan_version, step_id: step.step_id, attempt_id: step.attempt_id,
+        operation: step.operation, plugin, failed_receipt: proof.failed_receipt, accepted: proof.accepted, finding: proof.finding, effects_of_failed_call: 'unjudged' });
+      wrote.push(step.attempt_id);
+    }
+    if (!wrote.length) return [];
+    return foldWorkBook(await store.load(sessionId), context()).steps.filter(step => wrote.includes(step.attempt_id) && step.failure_closed?.kind === 'plugin_repaired_in_run').map(step => ({ task_id: step.task_id, step_id: step.step_id, operation: step.operation }));
+  };
+  return typeof store.workTransaction === 'function' ? store.workTransaction(sessionId, release) : release();
+}
+
 // A board is a fold of host facts. Model prose, nested receipts and thinking are not facts.
 export function foldWorkBook(session,context={}) {return foldWorkWithAudit(session,context,()=>auditExecution(session));}
 function foldWorkWithAudit(session, { active = new Set() } = {},auditFor) {
@@ -228,7 +299,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)||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;}
+  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)||closedPluginRepair(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.
@@ -320,6 +391,7 @@ function projectWork(book) {
     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.'})),
     publication_refusals: book.steps.filter(step=>step.failure_closed?.kind==='native_artifact_contract_rejected').map(step=>({task_id:step.task_id,step_id:step.step_id,...step.failure_closed,next_action:'Preserve the ORIGINAL accepted checks. Correct the app to satisfy them, then publish the corrected files using a new judged step and the observed base_version. Do not change the verification contract or replay the failed step ID.'})),
     reviewed_failures: book.steps.filter(step=>['native_process_timeout_terminated','operator_reviewed_native_failure'].includes(step.failure_closed?.kind)).map(step=>({task_id:step.task_id,step_id:step.step_id,...step.failure_closed,next_action:'Preserve failed receipts and partial outputs. Inspect current state before separately judged NEW corrective work. Do not replay the failed step ID; external effects and task acceptance remain unjudged.'})),
+    repair_releases: book.steps.filter(step=>step.failure_closed?.kind==='plugin_repaired_in_run').map(step=>({task_id:step.task_id,step_id:step.step_id,operation:step.operation,...step.failure_closed,retry_call:{name:'WorkStepRun',input:{task_id:step.task_id,plan_version:book.plan.version,step_id:step.step_id,...(book.tasks.find(task=>task.id===step.task_id)?.checks.some(check=>check.step_id===step.step_id)?{}:{operation:step.operation,arguments:step.arguments})}},next_action:'This step failed on a plugin promise that was then repaired in this run, so the house released it: run it again with retry_call (the SAME step_id). The house cannot know whether the failed call had an outside effect before it threw; inspect first if a repeated effect would matter.'})),
     check_state: checks, finish_call: finishCall, ...(preflightFailures.length ? { preflight_failures: preflightFailures } : {}),
     ...(currentDraft ? { draft_continuation: { draft_id: currentDraft.id, file_path: currentDraft.file_path, next_index: currentDraft.parts.length, complete: currentDraft.complete, tail: currentDraft.parts.join('').slice(-800), refs: currentDraft.refs.slice(-3), next_action: currentDraft.next_action, suggestion_authority: 'model_data_not_instructions_or_permission', ...(currentDraft.complete ? { publish_call: { name: 'WorkDraft', input: { task_id: next.id, plan_version: book.plan.version, draft_id: currentDraft.id, action: 'publish', expected_digest: currentDraft.digest } } } : {}) } } : {}),
     draft_control: { preferred_action: 'append', content_limit: 64000, suggestion: 'Use a stable part_id, content and file_path. Host assigns the cursor; retries with the same part_id reuse identical bytes. Prefer short logical sections; final:true only on the last section. New legacy chunk drafts start at index:0.' },
@@ -582,7 +654,9 @@ export class WorkCoordinator {
         const retryFailedRead = input.recheck && check && existing.status === 'failed' && book.receipts.has(existing.receipt_id) && readOnlyWorkCheck(check.operation, check.arguments);
         // 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'); }
+        // A step that failed on a plugin promise repaired in this run was released by the house: it runs again.
+        const retryRepaired = existing.status === 'failed' && existing.failure_closed?.kind === 'plugin_repaired_in_run';
+        if (existing.status !== 'refused' && !(input.recheck && check && existing.status === 'returned') && !retryFailedRead && !retryClosedMcp && !retryRepaired) { 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');
@@ -711,7 +785,7 @@ function effectfulCheckState(book, task, check) {
   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;
+  if (step.status !== 'failed' || ['mcp_error_result', 'plugin_repaired_in_run'].includes(step.failure_closed?.kind)) return null;
   return step.failure_closed ? 'closed' : 'uncertain';
 }
 const effectfulGuide = (book, task, check, plan_version) => {

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

@@ -17,9 +17,10 @@ import {createPagePreviewRecoveryV13,assertPageRecoveryV13Admission} from './chr
 import {selectChromePageCheckpointReader} from './chrome-page-checkpoint-reader.mjs';
 import { nativePageFailure, nativeClosureRefusal } from '../native-refusal.mjs';
 import { pagePublicationDiagnostic, markPagePublicationDiagnostic } from './chrome-page-diagnostics.mjs';
+import { REPAIR_NAMES, admitRepair, pluginFailure } from './chrome-repair.mjs';
 
 const prefix = 'plugin__chrome-lab__', own = ['ChromePublish', 'ChromeVerify', 'ChromeTest', 'ChromeFinish', 'ChromeDeliver', 'ChromeRecover', 'ChromeInspect'];
-const publicNames = new Set(['Read', 'Write', 'Edit', ...own, ...CHROME_SOURCE_NAMES]);
+const publicNames = new Set(['Read', 'Write', 'Edit', ...own, ...CHROME_SOURCE_NAMES, ...REPAIR_NAMES]);
 const empty = { type: 'object', properties: {}, additionalProperties: false };
 const error = (message, code = 'CHROME_TASK_CONFLICT') => nativePageFailure(message,code);
 const sourceHash = value => digest(value.files.map(({ path, sha256 }) => ({ path, sha256 })));
@@ -104,7 +105,8 @@ export async function prepareChromePageTask({ cwd, house, store, sessionId, exec
       throw failure;
     }
   };
-  const invoke = async (options, name, input = {}) => JSON.parse(await options.invoke(prefix + name, input, { signal: options.signal }));
+  // A plugin operation the house runs for a task action: a thrown handler error names the operation and its input (chrome-repair.mjs).
+  const invoke = async (options, name, input = {}) => { let text; try { text = await options.invoke(prefix + name, input, { signal: options.signal }); } catch (failure) { throw pluginFailure(failure, { house, options, plugin: 'chrome-lab', operation: name, input }); } return JSON.parse(text); };
   if(recoverySelected)publicationRecovery=createPagePreviewRecoveryV13({house,store,sessionId,cwd,task:brief,taskDigest,plan,policy,transportGuard:publicationRecoveryGuard,snapshot,state,save,invoke});
   let behaviorOperation;
   const context = async () => {
@@ -342,6 +344,9 @@ export async function prepareChromePageTask({ cwd, house, store, sessionId, exec
       return Boolean(frame && PAGE_VERIFIER_CONTRACT[frame.input.phase === 'run' ? 'run_ports' : 'final_ports'].includes(name) && view.input.target_id === (await state()).binding?.target_id && (name !== 'InspectValue' || view.input.context_unique_id === (await state()).binding.identity.context_unique_id));
     }
     if (['WorkPlanSet', 'WorkCheckRepair'].includes(view.operation)) return false;
+    // Repair by contract: its operations, the open candidate's files, and replays of calls that failed for this task.
+    const repair = await admitRepair(view, { policy, cwd, store, sessionId, prefix, plugin: 'chrome-lab', actions: [...own, PAGE_CASE_OPERATION, PAGE_BEHAVIOR_OPERATION] });
+    if (repair !== undefined) return repair;
     if (['Read', 'Write', 'Edit'].includes(view.operation)) return sourcePath(view.input.file_path, view.operation !== 'Read');
     if (CHROME_SOURCE_NAMES.includes(view.operation)) return Boolean(sourceAccess?.active() && await sourceAccess.admit(view));
     if (view.operation === 'FileInfo') return true; // Separate narrow artifact gate.
@@ -383,7 +388,7 @@ export async function prepareChromePageTask({ cwd, house, store, sessionId, exec
   if (initial.current?.status === 'pending') await executor.execute('WorkTaskUpdate', { task_id: 'chrome-task', plan_version: initial.plan.version, status: 'in_progress' });
   sourceAccess = bindChromeSource({ executor, store, sessionId, cwd, plan, taskDigest, pathAllowed: sourcePath, directory: brief.directory });
   await house.activateGovernance({ sessionId, plan, bindings: {
-    'runtime:chrome-task.scope': { revision: 'chrome-page-scope-v1', operations: ['*'], configuration_digest: taskDigest, check: scope },
+    'runtime:chrome-task.scope': { revision: 'chrome-page-scope-v1-repair2', operations: ['*'], configuration_digest: taskDigest, check: scope },
     'runtime:chrome-task.close': { revision: 'chrome-page-close-v1', operations: ['WorkTaskUpdate'], configuration_digest: taskDigest, check: close },
     'runtime:chrome-task.artifact-hash': { revision: 'chrome-page-artifact-v1', operations: ['FileInfo'], configuration_digest: digest({ taskDigest, artifact, contract_digest: hashOp.digest }), check: async view => !policy.denied.has('FileInfo') && view.contract_digest === hashOp.digest && (['WorkStepRun', 'WorkTaskUpdate'].includes(view.parent_operation) && digest(view.input) === digest({ file_path: artifact, hash: true }) || await sourceAccess.inspection(view)) },
   } });

package/src/workflows/chrome-repair.mjs

@@ -0,0 +1,88 @@
+import path from 'node:path';
+import { digest, PLUGIN_REPAIR_OPERATION_NAMES } from '../operations.mjs';
+
+// Repair by contract inside a coordinated Chrome task. There the model never calls a chrome-lab operation:
+// the house runs them as steps of the task's own actions, under a scope that admits exactly the calls the
+// task needs. A broken promise of the plugin therefore shows up inside a house action, and the model needs
+// three things to repair it without the scope opening anything else:
+//   - to be told which plugin operation failed, with what input and what error (pluginFailure);
+//   - the five repair operations beside the domain actions, while the plugin is repairable (REPAIR_NAMES);
+//   - the calls a repair makes to be admitted, and only those (admitRepair), all for the task's own plugin:
+//       · the repair operations themselves, proposed by the model, never nested, naming that plugin or an
+//         open candidate of that plugin;
+//       · Read/Edit/Write inside the candidate tree PluginRepairOpen opened for that plugin;
+//       · under Reproduce, Test and Accept, a plugin call that is EXACTLY one the house ran in this session
+//         for the task and that failed (same operation, same arguments), and only when the operation is
+//         one a repair may repeat (REPEATABLE).
+// The task's own uncertainty rules are untouched. REPEATABLE is an allow-list: the plugin's read-only
+// operations, plus Open. Every operation that writes outside (the deploy, the fixture preview, an
+// interaction, a message, arbitrary page JavaScript, and any operation added later) is never run again by
+// a repair: whether it took effect is settled by the task's reconciliation, which looks instead of
+// repeating. Opening the task's own popup is the one effect a repair may replay: nothing observes a popup
+// that was never opened, and a second one is seen by the reconciliation as ambiguous, never adopted.
+
+export const REPAIR_NAMES = Object.freeze([...PLUGIN_REPAIR_OPERATION_NAMES]);
+export const REPEATABLE = Object.freeze(['Status', 'Deployment', 'Targets', 'ReadDOM', 'Assert', 'Contexts', 'InspectValue', 'Console', 'WorkerDiagnostics', 'Open']);
+const REPLAYING = ['PluginRepairReproduce', 'PluginRepairTest', 'PluginRepairAccept'];
+const INPUT_BYTES = 4096, ERROR_CHARS = 700;
+const NO_REPEAT = 'This call may have taken effect before it failed. It is not repeated, and a repair cannot reproduce it: settle it with ChromeRecover, which observes what is really published and open.';
+
+// A candidate tree is <state>/plugin-candidates/<plugin>/<candidate>/tree (plugin-repair.mjs).
+function candidateOf(root) {
+  const parts = String(root).split(path.sep);
+  return parts.at(-1) === 'tree' && parts.at(-4) === 'plugin-candidates' ? { plugin: parts.at(-3), candidate: parts.at(-2) } : null;
+}
+/** The open candidate trees of `plugin`. */
+export const candidateRoots = (policy, plugin) => [...(policy?.candidateRoots ?? [])].filter(root => candidateOf(root)?.plugin === plugin);
+/** The open candidate tree of `plugin` that holds `file`, or null. */
+export function candidateRoot(policy, cwd, file, plugin) {
+  if (typeof file !== 'string' || typeof policy?.candidateRootOf !== 'function') return null;
+  const root = policy.candidateRootOf(path.resolve(cwd, file));
+  return root && candidateOf(root)?.plugin === plugin ? root : null;
+}
+
+/**
+ * A scope verdict for a call that belongs to a repair, or undefined when the call is none of a repair's
+ * business (the caller's own rules decide). `plugin` is the task's plugin and `prefix` its operation prefix;
+ * `actions` are the task's own operations, whose failed nested plugin calls may be replayed.
+ */
+export async function admitRepair(view, { policy, cwd, store, sessionId, prefix, plugin, actions }) {
+  if (REPAIR_NAMES.includes(view.operation)) {
+    if (view.parent_operation) return { allowed: false, reason: 'A repair operation is proposed by the model, never nested.' };
+    const own = ['PluginRepairReproduce', 'PluginRepairOpen'].includes(view.operation) ? view.input?.plugin === plugin
+      : candidateRoots(policy, plugin).some(root => candidateOf(root).candidate === view.input?.candidate);
+    return own ? true : { allowed: false, reason: `Inside this task only plugin ${plugin} and its own open candidate can be repaired.` };
+  }
+  if (['Read', 'Edit', 'Write'].includes(view.operation) && candidateRoot(policy, cwd, view.input?.file_path, plugin)) return true;
+  if (!REPLAYING.includes(view.parent_operation) || !view.operation.startsWith(prefix)) return undefined;
+  if (!REPEATABLE.includes(view.operation.slice(prefix.length))) return { allowed: false, reason: NO_REPEAT };
+  const rows = (await store.load(sessionId)).rows, wanted = digest(view.input);
+  const receipts = rows.filter(row => row.type === 'house_receipt');
+  const failed = receipts.some(row => row.operation === view.operation && row.status === 'failed' && row.arguments_digest === wanted
+    && receipts.some(parent => parent.invocation_id === row.parent_invocation_id && actions.includes(parent.operation)));
+  return failed ? true : { allowed: false, reason: 'In this coordinated task a repair replays exactly a plugin call the house ran for the task and that failed (the operation and input the failed action reported). No other plugin call is admitted.' };
+}
+
+// Refusals before the handler ran (permission, guard, scope, stale catalogue, invalid input): not the plugin's failure.
+const NOT_RUN = /^(HOUSE_(REFUSED|GUARD|STALE|AUTHORITY_CHANGED|SURFACE_CHANGED|INPUT_SCHEMA|PERMISSION_DENIED)|GOVERNANCE_REFUSED|TOOL_PACK_REQUIRED)$/;
+/**
+ * Called with the error of a plugin operation the house ran as a step of a task action. When the plugin's
+ * handler ran and threw (not a refusal before it ran, not an interrupted turn), the error is given
+ * `plugin_failure`: the plugin, the operation, the input and the error. For an operation a repair may
+ * replay it says how to reproduce it (when the repair operations are offered); for one the task never
+ * repeats it says so and names the reconciliation instead. The error keeps its identity, code and message;
+ * it is returned for the caller to rethrow. Synchronous and cheap: the task's own polling loops pass through here.
+ */
+export function pluginFailure(error, { house, options, plugin, operation, input }) {
+  if (!error || typeof error !== 'object' || error.plugin_failure || options?.signal?.aborted || NOT_RUN.test(String(error.code ?? ''))) return error;
+  let shown = {}; try { const text = JSON.stringify(input ?? {}); shown = Buffer.byteLength(text) <= INPUT_BYTES ? { input: JSON.parse(text) } : { input_omitted: 'too_large' }; } catch { shown = { input_omitted: 'not_json' }; }
+  const repairable = REPAIR_NAMES.every(name => house?.registry?.get(name));
+  const advice = !REPEATABLE.includes(operation) ? { next_action: NO_REPEAT }
+    : repairable && shown.input ? { repair: `The house ran this plugin operation for your action and it failed. If the cause is the page, the source or the lab, correct that. If the plugin itself broke its promise, reproduce exactly this call: PluginRepairReproduce {"plugin":"${plugin}","case":{"name":"<what it should do>","operation":"${operation}","input":<the input above>,"expect":<what it should return>}}, then PluginRepairOpen, fix the candidate, PluginRepairAccept. After an accepted repair continue with the task's own actions; an uncertain publication is settled with ChromeRecover, not repeated.` } : {};
+  try { error.plugin_failure = { plugin, operation, ...shown, ...(typeof error.code === 'string' ? { code: error.code } : {}), error: String(error.message ?? error).slice(0, ERROR_CHARS), ...advice }; } catch {}
+  return error;
+}
+
+const escaped = value => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+/** The alternatives a task's file_path pattern gains while candidate trees of `plugin` are open: each tree, escaped. */
+export const candidatePathAlternatives = (policy, plugin) => candidateRoots(policy, plugin).map(root => escaped(root) + '/');

package/src/workflows/chrome-task.mjs

@@ -10,6 +10,7 @@ import { CHROME_SOURCE_NAMES, bindChromeSource } from './chrome-source.mjs';
 import { PAGE_PREVIEW_RECOVERY_V13 } from './chrome-page-recovery-v13.mjs';
 import { suppliedInputsSchema, normalizeSuppliedInputs, verifySuppliedInputs, isSuppliedPath, assertSuppliedSnapshot } from './chrome-supplied-inputs.mjs';
 import { safeRelative, snapshotProject, chromeProjectNameSchema } from '../plugins/chrome-lab/project.mjs';
+import { REPAIR_NAMES, admitRepair, pluginFailure, candidatePathAlternatives } from './chrome-repair.mjs';
 
 const prefix = 'plugin__chrome-lab__';
 const PUBLIC = new Set(['Read', 'Edit', 'Write', 'ChromePublish', 'ChromeVerify', 'ChromeTest', 'ChromeFinish', 'ChromeRecover', 'ChromeInspect', 'ChromeDeliver']);
@@ -145,7 +146,9 @@ export async function prepareChromeTask({ cwd, house, store, sessionId, executor
   };
   const snapshot = async signal => {if(suppliedDigest)await verifySuppliedInputs(directory,brief.supplied_inputs,{signal});const result=await snapshotProject(cwd, brief.directory, { signal }); if(fixtureSource&&result.files.find(f=>f.path===brief.fixture.file)?.sha256!==fixtureSource)throw failure('The immutable test fixture changed.','CHROME_TASK_FIXTURE_CHANGED');if(suppliedDigest)assertSuppliedSnapshot(result,brief.supplied_inputs); return result;};
   const save = (options, value) => options.recordWork({ type: 'chrome_task_checkpoint', source: 'workflow_host', task_digest: taskDigest, state: value });
-  const invoke = async (options, name, input) => JSON.parse(await options.invoke(prefix+name, input, { signal: options.signal }));
+  // A plugin operation the house runs for a task action. When its handler throws, the error says which
+  // operation failed and with what input (chrome-repair.mjs), so the model can tell a broken plugin from a broken page.
+  const invoke = async (options, name, input) => { let text; try { text = await options.invoke(prefix+name, input, { signal: options.signal }); } catch (error) { throw pluginFailure(error, { house, options, plugin: 'chrome-lab', operation: name, input }); } return JSON.parse(text); };
   const assertReady = value => { if (value.stage.endsWith('_pending') || value.status === 'uncertain') throw failure('Publicación incierta: no se repite. Requiere reconciliación explícita.', 'CHROME_TASK_UNCERTAIN'); };
   const observeDocument = async (options,binding,previousIdentity) => {
     if(!observeIdentity)return;
@@ -416,6 +419,9 @@ export async function prepareChromeTask({ cwd, house, store, sessionId, executor
     if (policy.denied.has(view.operation)) return { allowed: false, reason: 'Explicit session deny.' };
     if (view.operation === 'WorkPlanSet' || view.operation === 'WorkCheckRepair') return { allowed: false, reason: 'Accepted task/criterion is immutable in this workflow.' };
     if (view.actor.kind === 'human' || view.surface === 'internal') return true;
+    // Repair by contract: its operations, the open candidate's files, and replays of calls that failed for this task.
+    const repair = await admitRepair(view, { policy, cwd, store, sessionId, prefix, plugin: 'chrome-lab', actions: OWN });
+    if (repair !== undefined) return repair;
     if (['Read','Edit','Write'].includes(view.operation)) return sourcePath(view.input.file_path,view.operation!=='Read');
     if (retainedSource && CHROME_SOURCE_NAMES.includes(view.operation)) return Boolean(sourceAccess?.active() && await sourceAccess.admit(view));
     if (!legacy && view.operation === 'FileInfo') return { allowed: true, reason: 'Subject to the separately enforced artifact-hash capability.' };
@@ -460,16 +466,19 @@ export async function prepareChromeTask({ cwd, house, store, sessionId, executor
   if (initial.current?.status === 'pending') await executor.execute('WorkTaskUpdate', { task_id: 'chrome-task', plan_version: initial.plan.version, status: 'in_progress' });
   if(retainedSource)sourceAccess=bindChromeSource({executor,store,sessionId,cwd,plan,taskDigest,pathAllowed:async(file,mutable)=>(await sourcePath(file,mutable)).allowed,directory:brief.directory});
   await house.activateGovernance({ sessionId, plan, bindings: {
-    'runtime:chrome-task.scope': { revision: suppliedInputs?'chrome-scope-v15':retainedSource?'chrome-scope-v14':workerInspection?'chrome-scope-v13':legacy ? 'chrome-scope-v3' : documentProof ? 'chrome-scope-v12' : pages ? 'chrome-scope-v11' : pipeline ? 'chrome-scope-v9' : currency ? 'chrome-scope-v7' : inspection ? 'chrome-scope-v6' : 'chrome-scope-v5', operations: ['*'], configuration_digest: taskDigest, check: scope },
+    'runtime:chrome-task.scope': { revision: (suppliedInputs?'chrome-scope-v15':retainedSource?'chrome-scope-v14':workerInspection?'chrome-scope-v13':legacy ? 'chrome-scope-v3' : documentProof ? 'chrome-scope-v12' : pages ? 'chrome-scope-v11' : pipeline ? 'chrome-scope-v9' : currency ? 'chrome-scope-v7' : inspection ? 'chrome-scope-v6' : 'chrome-scope-v5')+'-repair2', operations: ['*'], configuration_digest: taskDigest, check: scope },
     'runtime:chrome-task.close': { revision: 'chrome-close-v1', operations: ['WorkTaskUpdate'], configuration_digest: taskDigest, check: close },
     ...(!legacy ? { 'runtime:chrome-task.artifact-hash': { revision: retainedSource?'chrome-artifact-hash-v2':'chrome-artifact-hash-v1', operations: ['FileInfo'], configuration_digest: digest({ taskDigest, artifacts: declaredTask.artifacts, contract_digest: hashOperation.digest }), check: artifactHash } } : {})
   } });
   const project = snapshot => {
-    const definitions = snapshot.definitions().filter(tool => PUBLIC.has(tool.name) || retainedSource && CHROME_SOURCE_NAMES.includes(tool.name)).map(tool=>{
+    // The repair operations are offered beside the domain actions while the house offers them at all (a local
+    // plugin is repairable); while a candidate is open, the file tools also name its tree.
+    const candidates=candidatePathAlternatives(policy, 'chrome-lab');
+    const definitions = snapshot.definitions().filter(tool => PUBLIC.has(tool.name) || retainedSource && CHROME_SOURCE_NAMES.includes(tool.name) || REPAIR_NAMES.includes(tool.name)).map(tool=>{
       if(!pages||!['Read','Write','Edit',...(retainedSource?['SourceDraft']:[])].includes(tool.name))return tool;
       const escaped=value=>value.replace(/[.*+?^${}()|[\]\\]/g,'\\$&');
-      const view=structuredClone(tool);view.input_schema.properties.file_path.pattern='^('+escaped(brief.directory)+'/|'+escaped(directory)+'/).+$';
-      view.input_schema.properties.file_path.description='Accepted extension source path under '+brief.directory+'/. Host/plugin files are outside this task. '+(brief.fixture?'The fixture '+brief.fixture.file+' is read-only. ':'')+(suppliedDigest?'Supplied read-only inputs: '+brief.supplied_inputs.map(item=>item.file).join(', ')+'. ':'')+'Use existing source observations; reread only an unresolved file.';
+      const view=structuredClone(tool);view.input_schema.properties.file_path.pattern='^('+[escaped(brief.directory)+'/',escaped(directory)+'/',...(tool.name==='SourceDraft'?[]:candidates)].join('|')+').+$';
+      view.input_schema.properties.file_path.description='Accepted extension source path under '+brief.directory+'/. Host/plugin files are outside this task. '+(brief.fixture?'The fixture '+brief.fixture.file+' is read-only. ':'')+(suppliedDigest?'Supplied read-only inputs: '+brief.supplied_inputs.map(item=>item.file).join(', ')+'. ':'')+'Use existing source observations; reread only an unresolved file.'+(candidates.length&&tool.name!=='SourceDraft'?' While a plugin repair candidate is open, its directory (the one PluginRepairOpen returned) is admitted too.':'');
       return view;
     });
     const offered = new Set(definitions.map(tool => tool.name));