@entrorove/skill 0.1.23 → 0.1.25

package/cli.mjs

@@ -6,18 +6,19 @@ import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { compareVersions } from './version.mjs';
+import { credentialPath, readCredential, writeCredential } from './local-credential.mjs';
 import { runLocal } from './local-cli.mjs';
+import { runTaskMessageCli } from './task-message-cli.mjs';
 import { apiUrl, buildInvocation, invokeRemote, queryFlows, queryStatus } from './remote-client.mjs';
 const packageDir = path.dirname(fileURLToPath(import.meta.url));
-const reviewUrl = 'https://entrorove.com/api/ide-reviews';
+import { buildReview, submitSkillFeedback, feedbackNoticeVersion } from './review-client.mjs';
 const markerName = '.entrorove-managed.json';
 const installFiles = ['SKILL.md', 'CAPABILITY-MAP.md', 'AGREEMENT.md', 'manifest.json'];
 const markerSchema = 'entrorove.managed-install/1.0';
-const credentialSchema = 'entrorove.credential/1.0';
 const agreementSchema = 'entrorove.agreement-acceptance/1.0';
 const installLockWaitMs = 10_000;
 const installLockStaleMs = 120_000;
-export const agreementVersion = '2026-10-02.1';
+export const agreementVersion = feedbackNoticeVersion;
 
 function sha256(content) {
   return createHash('sha256').update(content).digest('hex');
@@ -25,7 +26,8 @@ function sha256(content) {
 
 
 async function readJson(file) {
-  const value = JSON.parse(await fs.readFile(file, 'utf8'));
+  let value;
+  try { value = JSON.parse(await fs.readFile(file, 'utf8')); } catch { throw new Error('Invalid JSON object'); }
   if (!value || typeof value !== 'object' || Array.isArray(value)) {
     throw new Error(`Invalid JSON object: ${file}`);
   }
@@ -59,18 +61,6 @@ function globalInstallPath(home = os.homedir()) {
   return path.join(home, '.codex', 'skills', 'entrorove');
 }
 
-function credentialPath(home = os.homedir()) {
-  if (process.platform === 'win32') {
-    const appData = process.env.LOCALAPPDATA;
-    if (!appData || !path.isAbsolute(appData)) throw new Error('LOCALAPPDATA is required');
-    return path.join(appData, 'Entrorove', 'credential.json');
-  }
-  if (process.platform === 'darwin') {
-    return path.join(home, 'Library', 'Application Support', 'Entrorove', 'credential.json');
-  }
-  return path.join(home, '.local', 'share', 'entrorove', 'credential.json');
-}
-
 function agreementPath(home = os.homedir()) {
   return path.join(path.dirname(credentialPath(home)), 'agreement.json');
 }
@@ -298,12 +288,13 @@ async function cleanProjectDuplicates(target, cwd) {
 export async function install({ home = os.homedir(), cwd = process.cwd() } = {}) {
   const bundle = await sourceBundle();
   const target = globalInstallPath(home);
+  const stale = await agreementStale(home);
   const parent = path.dirname(target);
   await fs.mkdir(parent, { recursive: true, mode: 0o700 });
   return withInstallLock(parent, async () => {
     const updated = await updateGlobalInstall(target, bundle);
     const removed = await cleanProjectDuplicates(target, cwd);
-    return { version: bundle.manifest.version, updated, removed };
+    return { version: bundle.manifest.version, updated, removed, agreementStale: stale };
   });
 }
 
@@ -313,7 +304,8 @@ async function stdinJson() {
     raw += chunk;
     if (raw.length > 1_000_000) throw new Error('Input is too large');
   }
-  const value = JSON.parse(raw);
+  let value;
+  try { value = JSON.parse(raw); } catch { throw new Error('Input must be valid JSON'); }
   if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('Input must be a JSON object');
   return value;
 }
@@ -325,38 +317,6 @@ async function preparePrivateDirectory(parent) {
   if (process.platform !== 'win32') await fs.chmod(parent, 0o700);
 }
 
-async function writeCredential(token, home) {
-  if (typeof token !== 'string' || !/^ent_[A-Za-z0-9_-]{43}$/.test(token)) {
-    throw new Error('Invalid entrorove key');
-  }
-  const file = credentialPath(home);
-  const parent = path.dirname(file);
-  await preparePrivateDirectory(parent);
-  const existing = await statOrNull(file);
-  if (existing && (!existing.isFile() || existing.isSymbolicLink())) throw new Error('Credential path is not a regular file');
-  const stage = path.join(parent, `.credential-${randomUUID()}.tmp`);
-  const handle = await fs.open(stage, 'wx', 0o600);
-  try {
-    await handle.writeFile(JSON.stringify({ schemaVersion: credentialSchema, token }) + '\n');
-    await handle.sync();
-  } finally {
-    await handle.close();
-  }
-  await fs.rename(stage, file);
-  if (process.platform !== 'win32') await fs.chmod(file, 0o600);
-}
-
-async function readCredential(home) {
-  const file = credentialPath(home);
-  const stat = await fs.lstat(file);
-  if (!stat.isFile() || stat.isSymbolicLink()) throw new Error('Credential path is not a regular file');
-  if (process.platform !== 'win32' && (stat.mode & 0o077) !== 0) throw new Error('Credential permissions must be 0600');
-  const data = await readJson(file);
-  if (data.schemaVersion !== credentialSchema || typeof data.token !== 'string'
-    || !/^ent_[A-Za-z0-9_-]{43}$/.test(data.token)) throw new Error('Invalid credential file');
-  return data.token;
-}
-
 async function agreementAccepted(home) {
   const file = agreementPath(home);
   const stat = await statOrNull(file);
@@ -371,6 +331,22 @@ async function agreementAccepted(home) {
     && Number.isFinite(Date.parse(data.acceptedAt));
 }
 
+async function agreementStale(home) {
+  const file = agreementPath(home);
+  const stat = await statOrNull(file);
+  if (!stat) return false;
+  if (!stat.isFile() || stat.isSymbolicLink()) return true;
+  if (process.platform !== 'win32' && (stat.mode & 0o077) !== 0) return true;
+  try {
+    const data = await readJson(file);
+    return data.schemaVersion !== agreementSchema || data.version !== agreementVersion
+      || data.answer !== 'accept' || typeof data.acceptedAt !== 'string'
+      || !Number.isFinite(Date.parse(data.acceptedAt));
+  } catch {
+    return true;
+  }
+}
+
 async function writeAgreementAcceptance(data, home) {
   if (Object.keys(data).sort().join(',') !== 'answer,version'
     || data.version !== agreementVersion || !['accept', 'decline'].includes(data.answer)) {
@@ -398,9 +374,9 @@ async function writeAgreementAcceptance(data, home) {
 
 export { buildInvocation };
 
-function remoteDependencies() {
+export function remoteDependencies(home = os.homedir()) {
   return {
-    install, agreementAccepted, agreementRequired, readCredential, home: os.homedir(),
+    install: () => install({ home }), agreementAccepted, agreementRequired, readCredential, home,
     apiOrigin: () => new URL(apiUrl).origin,
   };
 }
@@ -409,37 +385,11 @@ async function invoke(data) {
   return invokeRemote(data, remoteDependencies());
 }
 
-export function buildReview(data) {
-  if (!data || typeof data !== 'object' || Array.isArray(data)
-    || Object.keys(data).sort().join(',') !== 'comment,ide,publicConsent,rating'
-    || typeof data.ide !== 'string' || !/^[\p{L}\p{N} .+_-]{2,48}$/u.test(data.ide.trim())
-    || !Number.isInteger(data.rating) || data.rating < 1 || data.rating > 5
-    || typeof data.comment !== 'string' || data.comment.trim().length < 4
-    || data.comment.trim().length > 280 || data.publicConsent !== true) {
-    throw new Error('Expected user-authored review with ide, rating 1-5, comment, and publicConsent:true');
-  }
-  return {
-    url: reviewUrl,
-    body: {
-      ide: data.ide.trim(), rating: data.rating,
-      comment: data.comment.trim(), publicConsent: true,
-    },
-  };
-}
+export { buildReview };
 
 async function submitReview(data) {
-  const review = buildReview(data);
-  const token = await readCredential(os.homedir());
-  const response = await fetch(review.url, {
-    method: 'POST', redirect: 'error', signal: AbortSignal.timeout(15_000),
-    headers: { 'content-type': 'application/json', authorization: `Bearer ${token}` },
-    body: JSON.stringify(review.body),
-  });
-  if (!response.ok) throw new Error(`entrorove review failed: HTTP ${response.status}`);
-  const result = await response.json();
-  if (result?.published !== true || typeof result.id !== 'string') {
-    throw new Error('Invalid entrorove review response');
-  }
+  const result = await submitSkillFeedback(data, remoteDependencies());
+  if (result.error === 'agreement-required') process.exitCode = 2;
   process.stdout.write(JSON.stringify(result) + '\n');
 }
 
@@ -458,6 +408,8 @@ async function main() {
     process.stdout.write(JSON.stringify({ accepted, version: agreementVersion }) + '\n');
   } else if (command === 'invoke' && args.length === 0) {
     await invoke(await stdinJson());
+  } else if (command === 'host-message') {
+    await runTaskMessageCli(args, await stdinJson(), remoteDependencies());
   } else if (command === 'review' && args.length === 0) {
     await submitReview(await stdinJson());
   } else if (command === 'status' && args.length === 1) {
@@ -479,12 +431,12 @@ async function main() {
   } else if (command === 'local') {
     await runLocal(args);
   } else {
-    throw new Error('Usage: entrorove install | configure | agreement | invoke | status <requestId> | flows | review | local (JSON on stdin)');
+    throw new Error('Usage: entrorove install | configure | agreement | invoke | host-message [adapterModulePath] | status <requestId> | flows | review | local (JSON on stdin)');
   }
 }
 if (process.argv[1] && realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url))) {
   main().catch((error) => {
-    process.stderr.write(`${error.message}\n`);
+    process.stderr.write(`${error instanceof SyntaxError ? 'Invalid JSON data' : error.message}\n`);
     process.exitCode = 1;
   });
 }

package/local-approved-plan.mjs

@@ -1,9 +1,11 @@
+import { LOCAL_OPERATION_SCHEMAS } from './local-contracts.mjs';
 import { createHash, createPrivateKey, createPublicKey, randomUUID, sign } from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { promises as fs, constants } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { performance } from 'node:perf_hooks';
+import { assertBudgetRunnerAllowed } from './local-budget-reads.mjs';
 
 export const RUNNER_SCHEMA = 'entrorove.validator-local-runner/1.0';
 export const PLAN_SCHEMA = 'validator.execution-plan/1.0';
@@ -18,24 +20,37 @@ function canonical(value) { if (Array.isArray(value)) return `[${value.map(canon
 function safeRelative(value, label = 'path') { if (typeof value !== 'string' || !value || value !== value.normalize('NFC') || path.isAbsolute(value) || /^[A-Za-z]:/.test(value) || value.includes('\\') || /[\u0000-\u001f\u007f]/.test(value) || value.split('/').some(part => !part || part === '.' || part === '..')) fail('ENTROROVE_PATH_UNSAFE', `${label} must be a normalized relative path`); return value; }
 function inside(root, target, label) { const relative = path.relative(root, target); if (relative === '' || (!path.isAbsolute(relative) && relative !== '..' && !relative.startsWith(`..${path.sep}`))) return; fail('ENTROROVE_PATH_ESCAPE', `${label} escapes repositoryRoot`); }
 async function rootOf(value) { if (typeof value !== 'string' || !path.isAbsolute(value)) fail('ENTROROVE_ROOT_INVALID', 'repositoryRoot must be absolute'); const stat = await fs.lstat(value); if (!stat.isDirectory() || stat.isSymbolicLink()) fail('ENTROROVE_ROOT_INVALID', 'repositoryRoot must be a real directory'); return fs.realpath(value); }
-async function regular(file, max, privateFile = false) { const stat = await fs.lstat(file); if (!stat.isFile() || stat.isSymbolicLink() || stat.size > max) fail('ENTROROVE_FILE_INVALID', 'control file must be a bounded regular file'); if (privateFile && process.platform !== 'win32' && ((typeof process.getuid === 'function' && stat.uid !== process.getuid()) || (stat.mode & 0o777) !== 0o600 || stat.nlink !== 1)) fail('ENTROROVE_CONTROL_PERMISSIONS', 'control file must be owned and mode 0600'); return { bytes: await fs.readFile(file), sha256: digest(await fs.readFile(file)) }; }
+async function regular(file, max, privateFile = false) { const stat = await fs.lstat(file); if (!stat.isFile() || stat.isSymbolicLink() || stat.size > max) fail('ENTROROVE_FILE_INVALID', 'control file must be a bounded regular file'); if (privateFile && process.platform !== 'win32' && ((typeof process.getuid === 'function' && stat.uid !== process.getuid()) || (stat.mode & 0o777) !== 0o600 || stat.nlink !== 1)) fail('ENTROROVE_CONTROL_PERMISSIONS', 'control file must be owned and mode 0600'); const bytes = await fs.readFile(file); return { bytes, sha256: digest(bytes) }; }
 async function projectFile(root, relative) { const safe = safeRelative(relative); const target = path.resolve(root, ...safe.split('/')); inside(root, target, safe); const stat = await fs.lstat(target); if (!stat.isFile() || stat.isSymbolicLink() || await fs.realpath(target) !== target) fail('ENTROROVE_FILE_INVALID', `${safe} must be a regular file`); return { path: safe, target, stat, ...(await regular(target, RUNNER_LIMITS.maxFileBytes)) }; }
 async function externalFile(root, value, label) { if (typeof value !== 'string' || !path.isAbsolute(value)) fail('ENTROROVE_CONTROL_PATH', `${label} must be an absolute path`); const entry = await fs.lstat(value); if (!entry.isFile() || entry.isSymbolicLink()) fail('ENTROROVE_CONTROL_FILE', `${label} must be a regular non-symlink file`); const target = await fs.realpath(value); const relative = path.relative(root, target); if (relative === '' || (!path.isAbsolute(relative) && relative !== '..' && !relative.startsWith(`..${path.sep}`))) fail('ENTROROVE_PATH_ESCAPE', `${label} must be outside repositoryRoot`); return { path: target, ...(await regular(target, RUNNER_LIMITS.maxControlBytes, true)) }; }
 function exactObject(value, fields, label) { if (!value || typeof value !== 'object' || Array.isArray(value) || Object.keys(value).sort().join('|') !== [...fields].sort().join('|')) fail('ENTROROVE_PLAN_FIELDS', `${label} has invalid fields`); return value; }
 function boundedInt(value, max, label) { if (!Number.isSafeInteger(value) || value <= 0 || value > max) fail('ENTROROVE_LIMIT_INVALID', `${label} must be a positive bounded integer`); }
-function planArtifact(files) { return digest(canonical(files)); }
+function planArtifact(files) { return validatorPlanArtifact(files); }
+function validatorPlanArtifact(files) { return digest(`validator.file-manifest/1.0\n${files.map(file => `${file.path}\0${file.sha256}`).join('\n')}`); }
 
-function validatePlan(plan) {
-  exactObject(plan, ['schemaVersion', 'frozen', 'planId', 'validationRunId', 'memberId', 'chainId', 'artifactSha256', 'files', 'tests', 'policy', 'goldenBaseline', 'contracts'], 'execution plan');
+function validatePlan(plan, artifactDigest = planArtifact) {
+  exactObject(plan, ['schemaVersion', 'frozen', 'planId', 'validationRunId', 'memberId', 'chainId', 'artifactSha256', 'files', 'tests', 'policy', 'goldenBaseline', 'contracts', ...(plan?.evidencePolicy === undefined ? [] : ['evidencePolicy'])], 'execution plan');
   if (plan.schemaVersion !== PLAN_SCHEMA || plan.frozen !== true || !ID.test(plan.planId) || !ID.test(plan.validationRunId) || !ID.test(plan.memberId) || !ID.test(plan.chainId) || !SHA256.test(plan.artifactSha256) || !Array.isArray(plan.files) || plan.files.length === 0 || plan.files.length > RUNNER_LIMITS.maxFiles) fail('ENTROROVE_PLAN_INVALID', 'plan must be frozen and bounded');
   for (let i = 0; i < plan.files.length; i += 1) { const file = exactObject(plan.files[i], ['path', 'sha256'], 'manifest entry'); safeRelative(file.path); if (!SHA256.test(file.sha256) || (i > 0 && plan.files[i - 1].path >= file.path)) fail('ENTROROVE_PLAN_MANIFEST', 'manifest paths must be sorted and unique'); }
-  if (planArtifact(plan.files) !== plan.artifactSha256) fail('ENTROROVE_PLAN_MANIFEST', 'artifact manifest digest mismatch');
+  if (artifactDigest(plan.files) !== plan.artifactSha256) fail('ENTROROVE_PLAN_MANIFEST', 'artifact manifest digest mismatch');
   const policy = exactObject(plan.policy, ['executable', 'executableSha256', 'args', 'environment', 'timeoutMs', 'maxOutputBytes', 'requiredExitCode'], 'execution policy');
   if (typeof policy.executable !== 'string' || !path.isAbsolute(policy.executable) || !SHA256.test(policy.executableSha256) || !Array.isArray(policy.args) || policy.args.length > 128 || policy.args.some(value => typeof value !== 'string' || value.includes('\0') || value.length > 4096)) fail('ENTROROVE_POLICY_INVALID', 'executable and args are invalid');
   if (!policy.environment || typeof policy.environment !== 'object' || Array.isArray(policy.environment) || Object.keys(policy.environment).length > 64 || Object.entries(policy.environment).some(([key, value]) => !ENV.test(key) || typeof value !== 'string' || value.includes('\0') || value.length > 16_384)) fail('ENTROROVE_POLICY_ENVIRONMENT', 'environment must be explicit bounded strings');
   boundedInt(policy.timeoutMs, RUNNER_LIMITS.maxTimeoutMs, 'timeoutMs'); boundedInt(policy.maxOutputBytes, RUNNER_LIMITS.maxOutputBytes, 'maxOutputBytes'); if (policy.requiredExitCode !== 0) fail('ENTROROVE_POLICY_EXIT', 'requiredExitCode must be zero');
   if (!Array.isArray(plan.tests) || plan.tests.length === 0 || plan.tests.length > RUNNER_LIMITS.maxFiles) fail('ENTROROVE_PLAN_TESTS', 'tests must be non-empty');
   for (const test of plan.tests) { exactObject(test, ['testId', 'path'], 'test'); if (!ID.test(test.testId) || !plan.files.some(file => file.path === test.path) || !policy.args.includes(test.path)) fail('ENTROROVE_PLAN_TESTS', 'each test must be in the manifest and explicit in args'); }
+  if (plan.evidencePolicy !== undefined) {
+    const evidencePolicy = exactObject(plan.evidencePolicy, ['kind', 'runner', 'flowId', 'stepId', ...(plan.evidencePolicy?.localVerification === undefined ? [] : ['localVerification'])], 'evidence policy');
+    if (!['test', 'build', 'lint', 'security', 'benchmark'].includes(evidencePolicy.kind)
+      || !['local', 'trusted-runner', 'sandbox'].includes(evidencePolicy.runner)
+      || !ID.test(String(evidencePolicy.flowId ?? '')) || !ID.test(String(evidencePolicy.stepId ?? ''))) fail('ENTROROVE_EVIDENCE_POLICY', 'evidence policy must bind kind, runner, flow and step');
+    if (evidencePolicy.localVerification !== undefined) {
+      const local = exactObject(evidencePolicy.localVerification, ['operation', 'requestedTarget', 'requirementsSha256'], 'local verification policy');
+      if (!['sandbox-run', 'fuzz-input', 'perf-benchmark', 'intrusive-test'].includes(local.operation)
+        || typeof local.requestedTarget !== 'string' || !local.requestedTarget.trim() || local.requestedTarget.length > 2000
+        || !SHA256.test(String(local.requirementsSha256 ?? ''))) fail('ENTROROVE_EVIDENCE_POLICY', 'local verification requires its exact operation, target and requirements digest');
+    }
+  }
   if (plan.contracts?.archguard?.driftStatus === 'red') fail('ENTROROVE_ARCHGUARD_BLOCKED', 'ArchGuard red blocks execution'); return plan;
 }
 
@@ -52,8 +67,10 @@ async function signer(root, input, policy) {
 }
 
 async function authority(input) {
+  await assertBudgetRunnerAllowed(input);
   if (process.platform === 'win32' || typeof process.getuid !== 'function') fail('ENTROROVE_POSIX_REQUIRED', 'approved plan runner requires POSIX');
-  exactObject(input, ['repositoryRoot', 'planPath', 'approvalPath', 'signerConfigPath'], 'runner input'); const root = await rootOf(input.repositoryRoot); const planFile = await projectFile(root, input.planPath); if (planFile.bytes.length > RUNNER_LIMITS.maxControlBytes) fail('ENTROROVE_PLAN_SIZE', 'plan exceeds control limit');
+  const fields = ['repositoryRoot', 'planPath', 'approvalPath', 'signerConfigPath'];
+  exactObject(input, [...fields, ...['home', 'flowId'].filter(field => input[field] !== undefined)], 'runner input'); const root = await rootOf(input.repositoryRoot); const planFile = await projectFile(root, input.planPath); if (planFile.bytes.length > RUNNER_LIMITS.maxControlBytes) fail('ENTROROVE_PLAN_SIZE', 'plan exceeds control limit');
   let plan; try { plan = validatePlan(JSON.parse(planFile.bytes.toString('utf8'))); } catch (cause) { throw cause; } const approval = await validateApproval(root, input, planFile.sha256); const signing = await signer(root, input, plan.policy); const executable = await regular(plan.policy.executable, RUNNER_LIMITS.maxExecutableBytes); if (executable.sha256 !== plan.policy.executableSha256) fail('ENTROROVE_EXECUTABLE_HASH', 'executable SHA-256 mismatch');
   for (const file of plan.files) { const actual = await projectFile(root, file.path); if (actual.sha256 !== file.sha256) fail('ENTROROVE_PLAN_FILE_HASH', `${file.path} changed before execution`); }
   return { root, plan, planFile, approval, signing };
@@ -61,21 +78,63 @@ async function authority(input) {
 
 function runCommand(authority) {
   return new Promise((resolve, reject) => {
-    const started = performance.now(); const { policy } = authority.plan; const child = spawn(policy.executable, policy.args, { cwd: authority.root, env: { ...policy.environment }, shell: false, detached: true, stdio: ['ignore', 'pipe', 'pipe'] });
-    const stdout = []; const stderr = []; let bytes = 0; let dropped = 0; let timedOut = false; let terminating = false; let timer; const stdoutHash = createHash('sha256'); const stderrHash = createHash('sha256');
-    const terminate = () => { if (terminating) return; terminating = true; try { process.kill(-child.pid, 'SIGTERM'); } catch {} setTimeout(() => { try { process.kill(-child.pid, 'SIGKILL'); } catch {} }, 250).unref(); };
+    const started = performance.now(); const { policy } = authority.plan; const remaining = authority.executionDeadlineAt ? Date.parse(authority.executionDeadlineAt) - Date.now() : policy.timeoutMs;
+    if (remaining <= 0) { reject(Object.assign(new Error('workflow execution lease expired before process launch'), { code: 'ENTROROVE_WORKFLOW_EXPIRED' })); return; }
+    const child = spawn(policy.executable, policy.args, { cwd: authority.root, env: { ...policy.environment }, shell: false, detached: true, stdio: ['ignore', 'pipe', 'pipe'] });
+    const stdout = []; const stderr = []; let bytes = 0; let dropped = 0; let timedOut = false; let terminating = false; let spawned = false; let processStartedAt = null; let spawnError = null; let timer; let killTimer; const stdoutHash = createHash('sha256'); const stderrHash = createHash('sha256');
+    const terminate = () => { if (terminating) return; terminating = true; try { process.kill(-child.pid, 'SIGTERM'); } catch {} killTimer = setTimeout(() => { try { process.kill(-child.pid, 'SIGKILL'); } catch {} }, 250); killTimer.unref(); };
     const consume = (target, hash, chunk) => { const data = Buffer.from(chunk); hash.update(data); const keep = Math.max(0, Math.min(data.length, policy.maxOutputBytes - bytes)); if (keep) target.push(data.subarray(0, keep)); bytes += keep; dropped += data.length - keep; if (dropped) terminate(); };
-    child.stdout.on('data', chunk => consume(stdout, stdoutHash, chunk)); child.stderr.on('data', chunk => consume(stderr, stderrHash, chunk)); child.once('error', reject); timer = setTimeout(() => { timedOut = true; terminate(); }, policy.timeoutMs);
-    child.once('close', (exitCode, signal) => { clearTimeout(timer); resolve({ schemaVersion: RUNNER_SCHEMA, status: exitCode === 0 && signal === null && !timedOut && !dropped ? 'succeeded' : 'failed', exitCode, signal, timedOut, outputLimitExceeded: dropped > 0, durationMs: Math.max(0, Math.round(performance.now() - started)), stdout: Buffer.concat(stdout).toString('utf8'), stderr: Buffer.concat(stderr).toString('utf8'), stdoutSha256: stdoutHash.digest('hex'), stderrSha256: stderrHash.digest('hex'), capturedBytes: bytes, droppedBytes: dropped }); });
+    child.stdout.on('data', chunk => consume(stdout, stdoutHash, chunk)); child.stderr.on('data', chunk => consume(stderr, stderrHash, chunk));
+    child.once('spawn', () => { spawned = true; processStartedAt = new Date().toISOString(); }); child.once('error', error => { spawnError = error; terminate(); }); timer = setTimeout(() => { timedOut = true; terminate(); }, Math.min(policy.timeoutMs, remaining));
+    child.once('close', (exitCode, signal) => {
+      clearTimeout(timer); clearTimeout(killTimer);
+      const processResult = { schemaVersion: RUNNER_SCHEMA, status: exitCode === 0 && signal === null && !timedOut && !dropped && !spawnError ? 'succeeded' : 'failed', exitCode, signal, timedOut, outputLimitExceeded: dropped > 0, durationMs: Math.max(0, Math.round(performance.now() - started)), stdout: Buffer.concat(stdout).toString('utf8'), stderr: Buffer.concat(stderr).toString('utf8'), stdoutSha256: stdoutHash.digest('hex'), stderrSha256: stderrHash.digest('hex'), capturedBytes: bytes, droppedBytes: dropped,
+        ...(authority.objectPlan ? { started: spawned, startedAt: processStartedAt, finishedAt: new Date().toISOString(), executionDeadlineExceeded: timedOut && remaining <= policy.timeoutMs } : {}) };
+      if (spawnError) { spawnError.execution = { schemaVersion: RUNNER_SCHEMA, status: 'failed', process: processResult, evidence: [], effects: spawned ? 'unknown' : 'none' }; reject(spawnError); return; }
+      resolve(processResult);
+    });
   });
 }
-function subject(authority, result) { return { schemaVersion: 'validator.validation-subject/1.0', artifactSha256: authority.plan.artifactSha256, memberId: authority.plan.memberId, chainId: authority.plan.chainId, executedAt: new Date().toISOString(), files: authority.plan.files, validationRunId: authority.plan.validationRunId, planId: authority.plan.planId, tests: authority.plan.tests, policy: { command: [authority.plan.policy.executable, ...authority.plan.policy.args].map(value => JSON.stringify(value)).join(' '), requiredExitCode: 0, executionPlanSha256: authority.planFile.sha256 }, goldenBaseline: authority.plan.goldenBaseline, contracts: authority.plan.contracts, execution: { exitCode: result.exitCode, signal: result.signal, timedOut: result.timedOut, outputLimitExceeded: result.outputLimitExceeded } }; }
-function evidence(authority, result, sub) { const summary = result.timedOut ? 'Approved validation command exceeded its deadline' : result.outputLimitExceeded ? 'Approved validation command exceeded its output limit' : result.signal ? `Approved validation command ended on signal ${result.signal}` : `Approved validation command exited with code ${result.exitCode}`; const base = { schemaVersion: 'entrorove.test-evidence/2.0', evidenceId: `${authority.plan.validationRunId}:process`, kind: 'test', runner: authority.signing ? 'trusted-runner' : 'local', command: [authority.plan.policy.executable, ...authority.plan.policy.args].map(value => JSON.stringify(value)).join(' '), exitCode: result.exitCode, durationMs: result.durationMs, summary, artifactSha256: authority.plan.artifactSha256, subject: sub, subjectDigest: digest(canonical(sub)) };
-  if (!authority.signing || !Number.isInteger(result.exitCode)) return base; const privateKey = authority.signing.privateKey; const receiptCore = { schemaVersion: RECEIPT_SCHEMA, keyId: authority.signing.config.keyId, subjectDigest: base.subjectDigest, nonce: randomUUID(), issuedAt: new Date().toISOString(), expiresAt: new Date(Date.now() + authority.signing.config.receiptTtlMs).toISOString(), result: { runner: 'trusted-runner', passed: result.status === 'succeeded', exitCode: result.exitCode, durationMs: result.durationMs, summary } }; const receipt = { ...receiptCore, signature: sign(null, Buffer.from(canonical(receiptCore)), privateKey).toString('base64url') }; return { ...base, receipt };
+function subject(authority, result) { return { schemaVersion: 'validator.validation-subject/1.0', artifactSha256: authority.plan.artifactSha256, memberId: authority.plan.memberId, chainId: authority.plan.chainId, executedAt: new Date().toISOString(), files: authority.plan.files, validationRunId: authority.plan.validationRunId, planId: authority.plan.planId, tests: authority.plan.tests, policy: { command: [authority.plan.policy.executable, ...authority.plan.policy.args].map(value => JSON.stringify(value)).join(' '), requiredExitCode: 0, executionPlanSha256: authority.planFile.sha256, ...(authority.plan.evidencePolicy ? { evidenceKind: authority.plan.evidencePolicy.kind, evidenceRunner: authority.plan.evidencePolicy.runner, workflowBinding: { flowId: authority.plan.evidencePolicy.flowId, stepId: authority.plan.evidencePolicy.stepId }, ...(authority.plan.evidencePolicy.localVerification ? { localVerification: authority.plan.evidencePolicy.localVerification } : {}) } : {}) }, goldenBaseline: authority.plan.goldenBaseline, contracts: authority.plan.contracts, execution: { exitCode: result.exitCode, signal: result.signal, timedOut: result.timedOut, outputLimitExceeded: result.outputLimitExceeded } }; }
+function evidence(authority, result, sub) { const summary = result.timedOut ? 'Approved validation command exceeded its deadline' : result.outputLimitExceeded ? 'Approved validation command exceeded its output limit' : result.signal ? `Approved validation command ended on signal ${result.signal}` : `Approved validation command exited with code ${result.exitCode}`; const base = { schemaVersion: 'entrorove.test-evidence/2.0', evidenceId: `${authority.plan.validationRunId}:process`, kind: authority.plan.evidencePolicy?.kind ?? 'test', runner: authority.signing ? authority.plan.evidencePolicy?.runner ?? 'trusted-runner' : 'local', ...(authority.plan.evidencePolicy ? { flowId: authority.plan.evidencePolicy.flowId, stepId: authority.plan.evidencePolicy.stepId } : {}), command: [authority.plan.policy.executable, ...authority.plan.policy.args].map(value => JSON.stringify(value)).join(' '), exitCode: result.exitCode === null ? 1 : result.exitCode, durationMs: result.durationMs, summary, artifactSha256: authority.plan.artifactSha256, subject: sub, subjectDigest: digest(canonical(sub)) };
+  if (!authority.signing || !Number.isInteger(base.exitCode)) return base; const privateKey = authority.signing.privateKey; const receiptCore = { schemaVersion: RECEIPT_SCHEMA, keyId: authority.signing.config.keyId, subjectDigest: base.subjectDigest, nonce: randomUUID(), issuedAt: new Date().toISOString(), expiresAt: new Date(Date.now() + authority.signing.config.receiptTtlMs).toISOString(), result: { runner: 'trusted-runner', passed: result.status === 'succeeded', exitCode: result.exitCode === null ? 1 : result.exitCode, durationMs: result.durationMs, summary } }; const receipt = { ...receiptCore, signature: sign(null, Buffer.from(canonical(receiptCore)), privateKey).toString('base64url') }; return { ...base, receipt };
 }
 
 export async function runApprovedPlan(input) { const owner = await authority(input); const result = await runCommand(owner); try { const after = await authority(input); if (after.planFile.sha256 !== owner.planFile.sha256) fail('ENTROROVE_PLAN_CHANGED', 'plan changed during execution'); } catch (cause) { const execution = { schemaVersion: RUNNER_SCHEMA, status: 'failed', error: cause.message, process: result, evidence: [] }; const error = new Error(cause.message); error.code = cause.code; error.execution = execution; throw error; }
   const sub = subject(owner, result); const item = evidence(owner, result, sub); const status = !owner.signing && result.status === 'succeeded' ? 'incomplete' : result.status; return { schemaVersion: RUNNER_SCHEMA, status, planSha256: owner.planFile.sha256, approvalSha256: owner.approval.sha256, approvedBy: owner.approval.approval.approvedBy, subject: sub, process: result, evidence: [item], receipt: item.receipt ?? null, ...(owner.signing ? { receiptPublicKey: createPublicKey(owner.signing.privateKey).export({ format: 'der', type: 'spki' }).toString('base64') } : {}), signingBoundary: owner.signing ? 'configured-signature-only' : 'local-evidence-only' };
 }
 
-export const RUNNER_CAPABILITIES = Object.freeze({ schemaVersion: RUNNER_SCHEMA, operations: ['capabilities', 'run-approved-plan'], operationSchemas: { capabilities: { type: 'object', additionalProperties: false, required: [] }, 'run-approved-plan': { type: 'object', additionalProperties: false, required: ['repositoryRoot', 'planPath', 'approvalPath', 'signerConfigPath'] } }, limits: RUNNER_LIMITS, boundary: 'POSIX subprocess runner; external approval is required; local evidence remains incomplete without a configured signer.' });
+async function objectAuthority(input, afterExecution = false) {
+  await assertBudgetRunnerAllowed(input);
+  if (process.platform === 'win32' || typeof process.getuid !== 'function') fail('ENTROROVE_POSIX_REQUIRED', 'approved plan runner requires POSIX');
+  const fields = ['repositoryRoot', 'executionPlan', 'approvalPath', 'signerConfigPath', ...['home', 'flowId'].filter(field => input[field] !== undefined)];
+  exactObject(input, input?.executionDeadlineAt === undefined ? fields : [...fields, 'executionDeadlineAt'], 'object runner input');
+  const root = await rootOf(input.repositoryRoot); const bytes = Buffer.from(canonical(input.executionPlan) + '\n');
+  if (bytes.length > RUNNER_LIMITS.maxControlBytes) fail('ENTROROVE_PLAN_SIZE', 'plan exceeds control limit');
+  let parsed; try { parsed = JSON.parse(bytes.toString('utf8')); } catch { fail('ENTROROVE_PLAN_INVALID', 'execution plan must contain JSON values'); }
+  const plan = validatePlan(parsed, validatorPlanArtifact); const planFile = { bytes, sha256: digest(bytes) };
+  const approval = await validateApproval(root, input, planFile.sha256); const signing = await signer(root, input, plan.policy);
+  const executable = await regular(plan.policy.executable, RUNNER_LIMITS.maxExecutableBytes);
+  if (executable.sha256 !== plan.policy.executableSha256) fail('ENTROROVE_EXECUTABLE_HASH', 'executable SHA-256 mismatch');
+  for (const file of plan.files) { const actual = await projectFile(root, file.path); if (actual.sha256 !== file.sha256) fail('ENTROROVE_PLAN_FILE_HASH', `${file.path} changed before execution`); }
+  if (input.executionDeadlineAt !== undefined && (typeof input.executionDeadlineAt !== 'string' || !Number.isFinite(Date.parse(input.executionDeadlineAt))
+    || (!afterExecution && Date.parse(input.executionDeadlineAt) <= Date.now()))) fail('ENTROROVE_WORKFLOW_EXPIRED', 'workflow execution deadline is invalid or expired');
+  return { root, plan, planFile, approval, signing, objectPlan: true, ...(input.executionDeadlineAt === undefined ? {} : { executionDeadlineAt: input.executionDeadlineAt }) };
+}
+
+export async function runApprovedPlanObject(input) {
+  const owner = await objectAuthority(input); const result = await runCommand(owner);
+  try { const after = await objectAuthority(input, true); if (after.planFile.sha256 !== owner.planFile.sha256) fail('ENTROROVE_PLAN_CHANGED', 'plan changed during execution'); }
+  catch (cause) {
+    const error = new Error(cause.message); error.code = cause.code;
+    error.execution = { schemaVersion: RUNNER_SCHEMA, status: 'failed', error: cause.message, process: result, evidence: [], effects: 'unknown' }; throw error;
+  }
+  const sub = subject(owner, result); const item = evidence(owner, result, sub);
+  return { schemaVersion: RUNNER_SCHEMA, status: !owner.signing && result.status === 'succeeded' ? 'incomplete' : result.status,
+    planSha256: owner.planFile.sha256, approvalSha256: owner.approval.sha256, approvedBy: owner.approval.approval.approvedBy,
+    subject: sub, process: result, evidence: [item], receipt: item.receipt ?? null,
+    ...(owner.signing ? { receiptPublicKey: createPublicKey(owner.signing.privateKey).export({ format: 'der', type: 'spki' }).toString('base64') } : {}),
+    signingBoundary: owner.signing ? 'configured-signature-only' : 'local-evidence-only' };
+}
+
+export const RUNNER_CAPABILITIES = Object.freeze({ schemaVersion: RUNNER_SCHEMA, operations: ['capabilities', 'run-approved-plan'], operationSchemas: { capabilities: LOCAL_OPERATION_SCHEMAS.capabilities, 'run-approved-plan': LOCAL_OPERATION_SCHEMAS['run-approved-plan'] }, limits: RUNNER_LIMITS, boundary: 'POSIX subprocess runner; external approval is required; local evidence remains incomplete without a configured signer.' });