oxe-cc 1.7.0 → 1.8.3

package/lib/runtime/compiler/graph-compiler.js

@@ -26,7 +26,7 @@ function compile(plan, spec, options = {}) {
             mutation_scope: task.files,
             actions: buildActions(task),
             verify: {
-                must_pass: task.verifyCommand ? ['tests'] : [],
+                must_pass: task.verifyCommand ? (task.aceite.length > 0 ? task.aceite : ['tests']) : [],
                 acceptance_refs: task.aceite,
                 command: task.verifyCommand,
             },

package/lib/runtime/executor/action-tool-map.js

@@ -37,5 +37,9 @@ function selectToolsForActions(actions) {
             }
         }
     }
+    // finish_task is always available so the LLM can signal authoritative completion
+    if (!seen.has('finish_task') && built_in_tools_1.BUILT_IN_TOOLS.finish_task) {
+        result.push(built_in_tools_1.BUILT_IN_TOOLS.finish_task.schema);
+    }
     return result;
 }

package/lib/runtime/executor/built-in-tools.js

@@ -255,6 +255,32 @@ function runShell(command, cwd, timeoutMs) {
         proc.on('error', (err) => { clearTimeout(timer); resolve(`[error] ${err}`); });
     });
 }
+// ─── finish_task ──────────────────────────────────────────────────────────────
+const finishTask = {
+    idempotent: true,
+    schema: {
+        type: 'function',
+        function: {
+            name: 'finish_task',
+            description: 'Signal that the task is complete. Call this when ALL required actions have been performed.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    summary: { type: 'string', description: 'Summary of what was accomplished' },
+                    evidence_paths: { type: 'array', items: { type: 'string' }, description: 'Paths to files created or modified' },
+                },
+                required: ['summary'],
+            },
+        },
+    },
+    async execute(args, _cwd) {
+        return JSON.stringify({
+            __finish_task__: true,
+            summary: String(args.summary || ''),
+            evidence_paths: Array.isArray(args.evidence_paths) ? args.evidence_paths : [],
+        });
+    },
+};
 // ─── Registry ─────────────────────────────────────────────────────────────────
 exports.BUILT_IN_TOOLS = {
     read_file: readFile,
@@ -263,5 +289,6 @@ exports.BUILT_IN_TOOLS = {
     glob,
     grep,
     run_command: runCommand,
+    finish_task: finishTask,
 };
 exports.ALL_BUILT_IN_SCHEMAS = Object.values(exports.BUILT_IN_TOOLS).map((t) => t.schema);

package/lib/runtime/executor/llm-task-executor.d.ts

@@ -18,12 +18,15 @@ export interface LlmExecutorEvent {
     attempt: number;
     detail?: Record<string, unknown>;
 }
+export interface LlmExecuteOptions {
+    previousError?: string | null;
+}
 export declare class LlmTaskExecutor implements TaskExecutor {
     private readonly provider;
     private readonly registry?;
     private readonly onProgress?;
     constructor(provider: LlmProviderConfig, registry?: PluginRegistry | undefined, onProgress?: ((event: LlmExecutorEvent) => void) | undefined);
-    execute(node: GraphNode, lease: WorkspaceLease, runId: string, attempt: number): Promise<TaskResult>;
+    execute(node: GraphNode, lease: WorkspaceLease, runId: string, attempt: number, options?: LlmExecuteOptions): Promise<TaskResult>;
     private invokeToolCall;
     private emit;
 }

package/lib/runtime/executor/llm-task-executor.js

@@ -6,15 +6,15 @@ const built_in_tools_1 = require("./built-in-tools");
 const action_tool_map_1 = require("./action-tool-map");
 const node_prompt_builder_1 = require("./node-prompt-builder");
 const DEFAULT_SYSTEM_PROMPT = 'You are a precise software engineering agent. Use the tools provided to complete the task. ' +
-    'When the task is done, summarize what was accomplished in your final message without calling any tools.';
+    'When all actions are done, call finish_task with a summary of what was accomplished.';
 class LlmTaskExecutor {
     constructor(provider, registry, onProgress) {
         this.provider = provider;
         this.registry = registry;
         this.onProgress = onProgress;
     }
-    async execute(node, lease, runId, attempt) {
-        const prompt = (0, node_prompt_builder_1.buildNodePrompt)(node, lease, runId, attempt);
+    async execute(node, lease, runId, attempt, options = {}) {
+        const prompt = (0, node_prompt_builder_1.buildNodePrompt)(node, lease, runId, attempt, { previousError: options.previousError ?? null });
         const tools = (0, action_tool_map_1.selectToolsForActions)(node.actions);
         const cwd = lease.root_path;
         const maxTurns = this.provider.maxTurns ?? 10;
@@ -25,7 +25,10 @@ class LlmTaskExecutor {
         ];
         let finalOutput = '';
         const evidencePaths = [];
-        for (let turn = 0; turn < maxTurns; turn++) {
+        let completedByFinishTask = false;
+        let finishTaskSummary = '';
+        let turn = 0;
+        for (; turn < maxTurns; turn++) {
             this.emit({ type: 'turn_start', nodeId: node.id, attempt, detail: { turn } });
             let response;
             try {
@@ -60,12 +63,45 @@ class LlmTaskExecutor {
                 serialResults.push(await this.invokeToolCall(tc, cwd, node, evidencePaths));
             }
             messages.push(...concurrentResults, ...serialResults);
+            // Detect finish_task call — authoritative completion signal
+            const allResults = [...concurrentResults, ...serialResults];
+            const finishResult = allResults.find((r) => r.name === 'finish_task');
+            if (finishResult) {
+                try {
+                    const parsed = JSON.parse(finishResult.content);
+                    if (parsed.__finish_task__) {
+                        completedByFinishTask = true;
+                        finishTaskSummary = parsed.summary || '';
+                        if (Array.isArray(parsed.evidence_paths)) {
+                            evidencePaths.push(...parsed.evidence_paths.filter((p) => typeof p === 'string'));
+                        }
+                    }
+                }
+                catch { /* ignore parse errors */ }
+                if (completedByFinishTask)
+                    break;
+            }
+        }
+        const completedBy = completedByFinishTask
+            ? 'finish_task'
+            : turn < maxTurns
+                ? 'no_tool_call'
+                : 'turn_limit_exhausted';
+        if (completedBy === 'turn_limit_exhausted') {
+            return {
+                success: false,
+                failure_class: 'llm',
+                evidence: evidencePaths,
+                output: finalOutput || `Task exhausted ${maxTurns} turns without calling finish_task`,
+                completed_by: completedBy,
+            };
         }
         return {
             success: true,
             failure_class: null,
             evidence: evidencePaths,
-            output: finalOutput,
+            output: completedByFinishTask ? (finishTaskSummary || finalOutput) : finalOutput,
+            completed_by: completedBy,
         };
     }
     async invokeToolCall(tc, cwd, node, evidencePaths) {

package/lib/runtime/executor/node-prompt-builder.d.ts

@@ -1,3 +1,6 @@
 import type { GraphNode } from '../compiler/graph-compiler';
 import type { WorkspaceLease } from '../models/workspace';
-export declare function buildNodePrompt(node: GraphNode, lease: WorkspaceLease, runId: string, attempt: number): string;
+export interface NodePromptOptions {
+    previousError?: string | null;
+}
+export declare function buildNodePrompt(node: GraphNode, lease: WorkspaceLease, runId: string, attempt: number, options?: NodePromptOptions): string;

package/lib/runtime/executor/node-prompt-builder.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildNodePrompt = buildNodePrompt;
-function buildNodePrompt(node, lease, runId, attempt) {
+function buildNodePrompt(node, lease, runId, attempt, options = {}) {
     const lines = [
         `# Tarefa: ${node.title}`,
         '',
@@ -11,6 +11,14 @@ function buildNodePrompt(node, lease, runId, attempt) {
     if (node.mutation_scope.length > 0) {
         lines.push(`**Escopo de mutação:** ${node.mutation_scope.join(', ')}`);
     }
+    if (attempt > 1 && options.previousError) {
+        lines.push('', '## Contexto da tentativa anterior');
+        lines.push(`Esta é a tentativa **${attempt}**. A tentativa anterior falhou:`);
+        lines.push('', '```');
+        lines.push(String(options.previousError).slice(0, 2000));
+        lines.push('```', '');
+        lines.push('Analise o erro e tente uma abordagem diferente.');
+    }
     if (node.actions.length > 0) {
         lines.push('', '## Ações requeridas');
         for (const action of node.actions) {
@@ -31,6 +39,9 @@ function buildNodePrompt(node, lease, runId, attempt) {
     if (node.verify.command) {
         lines.push('', `**Verificação:** \`${node.verify.command}\``);
     }
-    lines.push('', 'Execute as ações acima usando as ferramentas disponíveis e confirme o resultado.');
+    lines.push('', '## Conclusão da tarefa');
+    lines.push('Quando **todas** as ações estiverem concluídas, chame `finish_task` com um resumo do que foi realizado.');
+    lines.push('NÃO chame `finish_task` antes de completar todas as ações requeridas.');
+    lines.push('', 'Execute as ações acima usando as ferramentas disponíveis.');
     return lines.join('\n');
 }

package/lib/runtime/models/failure.d.ts

@@ -2,4 +2,4 @@
  * Canonical failure classification used by TaskResult and VerificationManifest.
  * Both must import from this file — never redefine inline.
  */
-export type FailureClass = 'env' | 'policy' | 'test' | 'timeout' | 'evidence_missing' | null;
+export type FailureClass = 'env' | 'policy' | 'test' | 'timeout' | 'evidence_missing' | 'verify' | 'llm' | null;

package/lib/runtime/scheduler/scheduler.d.ts

@@ -14,9 +14,12 @@ export interface TaskResult {
     failure_class: FailureClass;
     evidence: string[];
     output: string;
+    completed_by?: string;
 }
 export interface TaskExecutor {
-    execute(node: GraphNode, lease: WorkspaceLease, runId: string, attemptNumber: number): Promise<TaskResult>;
+    execute(node: GraphNode, lease: WorkspaceLease, runId: string, attemptNumber: number, options?: {
+        previousError?: string | null;
+    }): Promise<TaskResult>;
 }
 export interface SchedulerOptions {
     maxRunDurationMs?: number;
@@ -70,6 +73,7 @@ export declare class Scheduler {
     getJournal(): RunJournal | null;
     static loadJournal(projectRoot: string, runId: string): RunJournal | null;
     private executeNode;
+    private verifyNode;
     private evaluatePolicyForNode;
     private requestGateForNode;
     private blockNode;

package/lib/runtime/scheduler/scheduler.js

@@ -12,6 +12,7 @@ const audit_trail_1 = require("../audit/audit-trail");
 const run_journal_1 = require("./run-journal");
 const decision_memo_1 = require("../decision/decision-memo");
 const capability_adapter_1 = require("../plugins/capability-adapter");
+const verification_compiler_1 = require("../verification/verification-compiler");
 class Scheduler {
     constructor() {
         this.cancelled = false;
@@ -350,6 +351,7 @@ class Scheduler {
         });
         let lease = null;
         let lastResult = null;
+        let lastError = null;
         const maxAttempts = node.policy.max_retries + 1;
         const quotaBlocked = this.consumeQuotaForNode(ctx, node);
         if (quotaBlocked) {
@@ -408,19 +410,31 @@ class Scheduler {
                     attempt_id: attemptId,
                     payload: { workspace_id: lease.workspace_id, strategy: lease.strategy },
                 });
-                lastResult = await this.executeNode(node, lease, ctx, attempt, attemptId);
+                lastResult = await this.executeNode(node, lease, ctx, attempt, attemptId, { previousError: lastError });
                 if (lastResult.success) {
-                    this.emit(ctx, {
-                        type: 'WorkItemCompleted',
-                        work_item_id: nodeId,
-                        attempt_id: attemptId,
-                        payload: { attempt_number: attempt, evidence: lastResult.evidence },
-                    });
-                    status.set(nodeId, 'completed');
-                    completed.push(nodeId);
-                    this.recordProgress();
-                    return;
+                    const verifyResult = await this.verifyNode(node, lease, ctx, attemptId, attempt);
+                    if (verifyResult && verifyResult.status === 'failed') {
+                        lastResult = {
+                            success: false,
+                            failure_class: 'verify',
+                            evidence: lastResult.evidence,
+                            output: `Verification failed: ${(verifyResult.gaps || []).join('; ') || 'checks did not pass'}`,
+                        };
+                    }
+                    else {
+                        this.emit(ctx, {
+                            type: 'WorkItemCompleted',
+                            work_item_id: nodeId,
+                            attempt_id: attemptId,
+                            payload: { attempt_number: attempt, evidence: lastResult.evidence },
+                        });
+                        status.set(nodeId, 'completed');
+                        completed.push(nodeId);
+                        this.recordProgress();
+                        return;
+                    }
                 }
+                lastError = lastResult.output || (lastResult.failure_class ?? 'unknown error');
                 if (lastResult.failure_class === 'policy')
                     break;
                 if (attempt < maxAttempts) {
@@ -454,6 +468,7 @@ class Scheduler {
                     evidence: [],
                     output: `[error_boundary] ${message}`,
                 };
+                lastError = lastResult.output;
                 if (attempt < maxAttempts) {
                     const backoffMs = Math.min(1000 * Math.pow(2, attempt - 1) + Math.random() * 500, 30000);
                     await new Promise(resolve => setTimeout(resolve, backoffMs));
@@ -509,11 +524,11 @@ class Scheduler {
     static loadJournal(projectRoot, runId) {
         return (0, run_journal_1.loadJournal)(projectRoot, runId);
     }
-    async executeNode(node, lease, ctx, attempt, attemptId) {
+    async executeNode(node, lease, ctx, attempt, attemptId, options = {}) {
         const primaryAction = pickPrimaryAction(node, ctx.pluginRegistry);
         const provider = primaryAction ? ctx.pluginRegistry?.toolProviderFor(primaryAction.type) : null;
         if (!provider || !primaryAction) {
-            return ctx.executor.execute(node, lease, ctx.runId, attempt);
+            return ctx.executor.execute(node, lease, ctx.runId, attempt, options);
         }
         ctx.auditTrail?.record('plugin_invoked', ctx.policyActor ?? 'runtime', {
             runId: ctx.runId,
@@ -573,6 +588,57 @@ class Scheduler {
             output: result.output,
         };
     }
+    async verifyNode(node, lease, ctx, attemptId, attempt) {
+        if (!node.verify?.command)
+            return null;
+        this.emit(ctx, {
+            type: 'VerificationStarted',
+            work_item_id: node.id,
+            payload: { command: node.verify.command, attempt_number: attempt },
+        });
+        const suite = {
+            checks: [{
+                    id: `inline-${node.id}`,
+                    type: 'custom',
+                    command: node.verify.command,
+                    evidence_type_expected: 'stdout',
+                    acceptance_ref: null,
+                    description: `Verify ${node.id}`,
+                }],
+            compiled_at: new Date().toISOString(),
+            spec_hash: '',
+            plan_hash: '',
+        };
+        let result;
+        try {
+            result = await (0, verification_compiler_1.verifyRun)({
+                suite,
+                cwd: lease.root_path,
+                timeoutMs: ctx.options?.verifyTimeoutMs ?? 60000,
+                runId: ctx.runId,
+                workItemId: node.id,
+                attemptNumber: attempt,
+                projectRoot: ctx.projectRoot,
+                pluginRegistry: ctx.pluginRegistry,
+            });
+        }
+        catch (err) {
+            this.emit(ctx, {
+                type: 'VerificationCompleted',
+                work_item_id: node.id,
+                attempt_id: attemptId,
+                payload: { status: 'error', error: String(err) },
+            });
+            return null;
+        }
+        this.emit(ctx, {
+            type: 'VerificationCompleted',
+            work_item_id: node.id,
+            attempt_id: attemptId,
+            payload: { status: result.status },
+        });
+        return result;
+    }
     evaluatePolicyForNode(node, ctx) {
         if (!ctx.policyEngine)
             return null;
@@ -603,8 +669,10 @@ class Scheduler {
         return persisted;
     }
     async requestGateForNode(node, ctx, decision) {
-        if (!ctx.gateManager)
+        if (!ctx.gateManager) {
+            console.warn('[scheduler] ctx.gateManager not configured — gates will not be persisted');
             return 'gate-missing-manager';
+        }
         const scope = inferGateScope(node);
         const primaryAction = pickPrimaryAction(node, ctx.pluginRegistry);
         const gate = await ctx.gateManager.request(scope, {

package/lib/runtime/verification/verification-compiler.js

@@ -92,15 +92,17 @@ async function runCheck(check, cwd, timeoutMs = 60000) {
     }
     const start = Date.now();
     try {
-        // Split command into program + args (simple split; no shell expansion)
-        const parts = check.command.split(/\s+/);
-        const prog = parts[0];
-        const args = parts.slice(1);
-        const result = (0, child_process_1.spawnSync)(prog, args, {
+        // Use shell so the full command string is interpreted (handles quotes, &&, node -e "...")
+        const isWin = process.platform === 'win32';
+        const shell = isWin ? 'cmd' : 'sh';
+        const shellArgs = isWin ? ['/c', check.command] : ['-c', check.command];
+        const result = (0, child_process_1.spawnSync)(shell, shellArgs, {
             cwd,
             encoding: 'utf8',
             timeout: timeoutMs,
             maxBuffer: 2 * 1024 * 1024,
+            // On Windows, prevent Node from re-quoting the args (preserves double-quotes inside node -e "...")
+            windowsVerbatimArguments: isWin,
         });
         const duration_ms = Date.now() - start;
         const status = result.status === 0 ? 'pass' : 'fail';

package/lib/sdk/index.cjs

@@ -17,10 +17,10 @@ const plugins = require('../../bin/lib/oxe-plugins.cjs');
 const dashboard = require('../../bin/lib/oxe-dashboard.cjs');
 const operational = require('../../bin/lib/oxe-operational.cjs');
 const azure = require('../../bin/lib/oxe-azure.cjs');
-const context = require('../../bin/lib/oxe-context-engine.cjs');
-const runtimeSemantics = require('../../bin/lib/oxe-runtime-semantics.cjs');
-const release = require('../../bin/lib/oxe-release.cjs');
-const rationality = require('../../bin/lib/oxe-rationality.cjs');
+const context = require('../../bin/lib/oxe-context-engine.cjs');
+const runtimeSemantics = require('../../bin/lib/oxe-runtime-semantics.cjs');
+const release = require('../../bin/lib/oxe-release.cjs');
+const rationality = require('../../bin/lib/oxe-rationality.cjs');
 
 const PACKAGE_ROOT = path.join(__dirname, '..', '..');
 
@@ -94,8 +94,12 @@ function parsePlan(planMd) {
       ? filesMatch[1].match(/`([^`]+)`/g)?.map((s) => s.replace(/`/g, '')) || []
       : [];
 
-    const verifyCmdMatch = rest.match(/Comando:\s*`([^`]+)`/i);
-    const verifyCommand = verifyCmdMatch ? verifyCmdMatch[1] : null;
+    // Accept: "Comando: `...`" (PT), "**Verify command:** `...`", "**Verificação:** `...`", "**Verification:** `...`"
+    // Use [^`]+ with dotAll so multiline commands inside backticks are captured
+    const verifyCmdMatch = rest.match(
+      /(?:Comando|Verify\s+command|Verificação|Verification):\s*`([^`]+)`/is
+    );
+    const verifyCommand = verifyCmdMatch ? verifyCmdMatch[1].trim() : null;
 
     const aceiteMatch = rest.match(/\*\*Aceite\s+vinculado:\*\*\s*([^\n]+)/i);
     const aceite = aceiteMatch
@@ -542,23 +546,23 @@ module.exports = {
   /** Parsing de artefatos OXE (PLAN, SPEC, STATE, hypotheses, confidence, lessons). */
   parsePlan,
   parseSpec,
-  parseHypotheses: context.parseHypotheses,
-  parseConfidenceVector: context.parseConfidenceVector,
-  parseExecutionPlanTasks: rationality.parsePlanTasks,
-  parseState,
+  parseHypotheses: context.parseHypotheses,
+  parseConfidenceVector: context.parseConfidenceVector,
+  parseExecutionPlanTasks: rationality.parsePlanTasks,
+  parseState,
   validateDecisionFidelity,
   parseLessonsMetrics,
   updateLessonMetric,
   deprecateLowEffectiveness,
 
   /** Estado do projeto, SPEC/PLAN, fase, config. */
-  health: {
-    loadOxeConfigMerged: health.loadOxeConfigMerged,
-    validateConfigShape: health.validateConfigShape,
-    buildHealthReport: health.buildHealthReport,
-    detectWorkspaceMode: health.detectWorkspaceMode,
-    shouldSuppressExecutionWorkspaceGates: health.shouldSuppressExecutionWorkspaceGates,
-    suggestNextStep: health.suggestNextStep,
+  health: {
+    loadOxeConfigMerged: health.loadOxeConfigMerged,
+    validateConfigShape: health.validateConfigShape,
+    buildHealthReport: health.buildHealthReport,
+    detectWorkspaceMode: health.detectWorkspaceMode,
+    shouldSuppressExecutionWorkspaceGates: health.shouldSuppressExecutionWorkspaceGates,
+    suggestNextStep: health.suggestNextStep,
     oxePaths: health.oxePaths,
     parseStatePhase: health.parseStatePhase,
     parseLastScanDate: health.parseLastScanDate,
@@ -572,11 +576,11 @@ module.exports = {
     planAgentsWarnings: health.planAgentsWarnings,
     phaseCoherenceWarnings: health.phaseCoherenceWarnings,
     specSectionWarnings: health.specSectionWarnings,
-    planWaveWarningsFixed: health.planWaveWarningsFixed,
-    planTaskAceiteWarnings: health.planTaskAceiteWarnings,
-    buildExecutionRationality: health.buildExecutionRationality,
-    executionRationalityWarningsFromSummary: health.executionRationalityWarningsFromSummary,
-    verifyGapsWithoutSummaryWarning: health.verifyGapsWithoutSummaryWarning,
+    planWaveWarningsFixed: health.planWaveWarningsFixed,
+    planTaskAceiteWarnings: health.planTaskAceiteWarnings,
+    buildExecutionRationality: health.buildExecutionRationality,
+    executionRationalityWarningsFromSummary: health.executionRationalityWarningsFromSummary,
+    verifyGapsWithoutSummaryWarning: health.verifyGapsWithoutSummaryWarning,
     expandExecutionProfile: health.expandExecutionProfile,
     ALLOWED_CONFIG_KEYS: health.ALLOWED_CONFIG_KEYS,
     EXECUTION_PROFILES: health.EXECUTION_PROFILES,
@@ -643,28 +647,28 @@ module.exports = {
   },
 
   /** Dashboard local: contexto consolidado e persistência de revisão do plano. */
-  dashboard: {
-    loadDashboardContext: dashboard.loadDashboardContext,
-    savePlanReviewStatus: dashboard.savePlanReviewStatus,
-    addPlanReviewComment: dashboard.addPlanReviewComment,
-    updatePlanReviewCommentStatus: dashboard.updatePlanReviewCommentStatus,
-  },
-
-  /** Release readiness: manifest, smoke matrix e checks de consistência antes de publicar. */
-  release: {
-    REQUIRED_RUNTIMES: release.REQUIRED_RUNTIMES,
-    WRAPPER_TARGETS: release.WRAPPER_TARGETS,
-    releasePaths: release.releasePaths,
-    collectWrapperHashes: release.collectWrapperHashes,
-    loadRuntimeSmokeReport: release.loadRuntimeSmokeReport,
-    loadRecoveryFixtureReport: release.loadRecoveryFixtureReport,
-    loadMultiAgentSoakReport: release.loadMultiAgentSoakReport,
-    buildReleaseManifest: release.buildReleaseManifest,
-    inspectCanonicalSource: release.inspectCanonicalSource,
-    evaluateReleaseManifest: release.evaluateReleaseManifest,
-    inspectReleaseReadiness: release.inspectReleaseReadiness,
-    checkReleaseConsistency: release.checkReleaseConsistency,
-  },
+  dashboard: {
+    loadDashboardContext: dashboard.loadDashboardContext,
+    savePlanReviewStatus: dashboard.savePlanReviewStatus,
+    addPlanReviewComment: dashboard.addPlanReviewComment,
+    updatePlanReviewCommentStatus: dashboard.updatePlanReviewCommentStatus,
+  },
+
+  /** Release readiness: manifest, smoke matrix e checks de consistência antes de publicar. */
+  release: {
+    REQUIRED_RUNTIMES: release.REQUIRED_RUNTIMES,
+    WRAPPER_TARGETS: release.WRAPPER_TARGETS,
+    releasePaths: release.releasePaths,
+    collectWrapperHashes: release.collectWrapperHashes,
+    loadRuntimeSmokeReport: release.loadRuntimeSmokeReport,
+    loadRecoveryFixtureReport: release.loadRecoveryFixtureReport,
+    loadMultiAgentSoakReport: release.loadMultiAgentSoakReport,
+    buildReleaseManifest: release.buildReleaseManifest,
+    inspectCanonicalSource: release.inspectCanonicalSource,
+    evaluateReleaseManifest: release.evaluateReleaseManifest,
+    inspectReleaseReadiness: release.inspectReleaseReadiness,
+    checkReleaseConsistency: release.checkReleaseConsistency,
+  },
 
   /** Runtime operacional: tracing, active run, catálogo de capabilities e memória em camadas. */
   operational: {

package/oxe/templates/PLAN.template.md

@@ -24,12 +24,14 @@ evidence_expectation: manifest | command | manual | mixed
 
 > Gerado a partir de `.oxe/SPEC.md`. Cada tarefa deve ter bloco **Verificar**.
 
-## Resumo
-
-- **Spec vinculada:** (data ou versão informal)
-- **Ondas:** (número)
-- **Tarefas:** (número)
-- **Artefatos racionais:** `IMPLEMENTATION-PACK`, `REFERENCE-ANCHORS`, `FIXTURE-PACK`
+## Resumo
+
+- **Spec vinculada:** (data ou versão informal)
+- **Ondas:** (número)
+- **Tarefas:** (número)
+- **Artefatos racionais:** `IMPLEMENTATION-PACK`, `REFERENCE-ANCHORS`, `FIXTURE-PACK`
+- **Público / outcome da spec:** …
+- **Padrão de validação dominante:** testes | smoke | manual guiado | mixed
 
 ## Autoavaliação do Plano
 
@@ -48,6 +50,7 @@ evidence_expectation: manifest | command | manual | mixed
 - **Alternativas descartadas:** (1–2 linhas)
 - **Condição para replanejar:** (critério objetivo)
 - **Bloqueadores de execução:** nenhum | listar gaps críticos
+- **Densidade operacional mínima confirmada:** paths | symbols | fixtures | anchors | checks
 
 <confidence_vector cycle="C-NN" generated_at="YYYY-MM-DDTHH:MM:SSZ">
   <dim name="requirements"   score="0.92" weight="25" note="completude dos requisitos" />
@@ -80,9 +83,17 @@ evidence_expectation: manifest | command | manual | mixed
 </hypothesis>
 -->
 
-## Dependências globais
-
-- (ex.: branch base, feature flags, migrations)
+## Dependências globais
+
+- (ex.: branch base, feature flags, migrations)
+
+## Contrato operacional da solução
+
+- **Write-set principal:** módulos/paths que concentram a mutação
+- **Modelo de conteúdo / dados a materializar:** …
+- **Interações ou fluxos obrigatórios:** …
+- **Persistência local/remota:** none | localStorage | API | outro
+- **Responsividade / acessibilidade obrigatória:** …
 
 ## Artefatos racionais de execução
 
@@ -118,18 +129,21 @@ evidence_expectation: manifest | command | manual | mixed
 ### T1 — (título)
 
 - **Arquivos alvo:** `src/exato.ts`
+- **Símbolos alvo:** `função`, `classe`, `componente`, `builder`, `schema`
 - **Depende de:** —
 - **Onda:** 1
 - **Complexidade:** S
 - **Risco:** low | medium | high | critical
 - **Evidência de entrada:** SPEC A1 | DISCUSS D-01 | RESEARCH RA-01 | codebase path
 - **Checkpoint:** nenhum | CHK-01
+- **Estado/fluxo coberto:** loading | empty | success | error | interação X
 - **Verificar:**
   - Comando: `…`
   - Manual: (opcional) …
 - **Implementar:** o mínimo para fazer a verificação acima passar.
 - **Aceite vinculado:** A1, A2 (IDs da tabela de critérios em SPEC.md)
 - **Contrato racional:** ver `IMPLEMENTATION-PACK.json` (task `T1`)
+- **Fixture/anchor obrigatório:** FX-01 | RA-01 | not_applicable
 - **Rollback/contensão:** obrigatório para risco high/critical; `not_applicable` se low/medium.
 
 ---