@entrorove/skill 0.1.37 → 0.1.38

package/ide-hook.mjs

@@ -0,0 +1,167 @@
+#!/usr/bin/env node
+import { realpathSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { ideSession, ideRuntime, bindIdeAccount, ideContext, ideDigest } from './ide-session.mjs';
+import { literalCommand, sdkCommand, readCommand, renderSdkCommand, installerCommand } from './ide-command.mjs';
+import { inspectIdeCodeMode } from './ide-code-mode.mjs';
+import { pathToFileURL } from 'node:url';
+import path from 'node:path';
+import { parseIdeResults, consumeIdeResults } from './ide-results.mjs';
+
+const output = (event, extra = {}) => ({ hookSpecificOutput: { hookEventName: event, ...extra } });
+const deny = reason => output('PreToolUse', { permissionDecision: 'deny', permissionDecisionReason: reason });
+const publicId = value => typeof value === 'string' && /^[A-Za-z0-9_-]{1,200}$/u.test(value);
+const readTools = new Set(['wait', 'view_image', 'list_mcp_resources', 'list_mcp_resource_templates', 'read_mcp_resource', 'web_search', 'update_plan', 'request_user_input', 'request_user_input_async']);
+function collectResult(state, values, local) {
+  const messages = [];
+  for (const result of values) {
+    const value = result.output ?? result;
+    if (typeof value.requestId === 'string' && /^[a-f0-9]{64}$/u.test(value.requestId)) state.requestId = value.requestId;
+    if (!local && value.flowId && value.requestId) state.remoteRequestId = value.requestId;
+    if (publicId(value.flowId)) {
+      if (state.flowId && state.flowId !== value.flowId) throw new Error('Returned flow replaced the original task');
+      state.flowId = value.flowId;
+    }
+    if (typeof value.taskNumber === 'string' && /^[0-9]{5}$/u.test(value.taskNumber)) {
+      if (state.taskId && state.taskId !== value.taskId) throw new Error('Returned cloud task replaced the original task');
+      state.taskId = value.taskId; state.taskNumber = value.taskNumber;
+    }
+    const nextStep = value.nextStep ?? value.result?.nextStep ?? value.result?.result?.nextStep;
+    if (value.status === 'needs-input' || value.result?.status === 'needs-input' || value.interaction || value.result?.interaction) state.phase = 'needs-input';
+    else if (['blocked', 'failed', 'incomplete'].includes(value.status) || ['blocked', 'failed', 'incomplete'].includes(value.result?.status)
+      || ['blocked', 'failed'].includes(value.taskStatus)) state.phase = 'blocked';
+    else if (nextStep || value.nextAction) state.phase = 'continuing';
+    else if (!local && (value.reports?.length || value.result?.reports?.length || ['completed','cancelled'].includes(value.taskStatus))
+      && result.feedback?.acknowledgement?.stored === true) state.phase = 'ended';
+    else if (local && value.status === 'verified') state.phase = 'continuing';
+    else if (value.status === 'started' || value.status === 'succeeded') state.phase = 'continuing';
+    if (nextStep) state.nextStep = { operation: nextStep.operation, payload: nextStep.payload };
+    const notices = [...(result.ideMessages ?? []), ...(value.ideMessages ?? []),
+      ...(value.schemaVersion === 'entrorove.ide-event/1.0' ? [value.message] : []), ...(value.events ?? []).map(item => item.message)];
+    for (const message of notices) {
+      if (typeof message !== 'string' || !message || message.length > 12000) continue;
+      const key = ideDigest({ taskId: state.taskId, message, receiptId: result.feedback?.receiptId });
+      if (!state.seen.includes(key)) { state.seen.push(key); messages.push(message); }
+    }
+    if (result.feedback?.acknowledgement?.stored === true) state.feedbackAcknowledged = true;
+  }
+  state.seen = state.seen.slice(-200);
+  return messages;
+}
+async function beforeTool(event, state, home) {
+  const command = event.tool_input?.command ?? event.tool_input?.cmd, parsed = literalCommand(command);
+  const isShell = ['Bash', 'exec_command', 'shell_command'].includes(event.tool_name);
+  const installer = isShell && installerCommand(parsed);
+  if (installer) {
+    if (state.active) {
+      state.readCalls ??= {};
+      state.readCalls[event.tool_use_id] = { toolUseId: event.tool_use_id, command: 'install' };
+    }
+    return output('PreToolUse', { permissionDecision: 'allow', updatedInput: { ...event.tool_input, command: installer,
+      ...(Object.hasOwn(event.tool_input ?? {}, 'cmd') ? { cmd: installer } : {}) } });
+  }
+  const namedSdk = parsed?.words.some(word => /^@entrorove\/skill(?:@[^ ]+)?$/u.test(word)
+    || /(?:@entrorove\/skill|entrorove-skill)\/cli\.mjs$/u.test(word));
+  if (!state.active && !namedSdk) return {};
+  const runtime = isShell && parsed ? await ideRuntime(home) : null;
+  const call = runtime && sdkCommand(parsed, runtime);
+  if (call) {
+    state.active = true;
+    if (call.args[0] !== 'configure') await bindIdeAccount(state, home);
+    const newStart = call.args[0] === 'cloud-task' || call.args[0] === 'invoke' && ['start','cloud-task'].includes(call.input?.operation);
+    if (newStart && (state.flowId || state.taskId) && state.phase !== 'ended') return deny('Entrorove：必须继续原任务，禁止用第二次 start 或 cloud-task 绕过原门禁。');
+    const discovery = ['invoke','local'].includes(call.args[0]) && ['capabilities','help'].includes(call.input?.operation ?? call.args[1]);
+    const observer = discovery || ['status','feedback','cloud-status','configure','agreement','install'].includes(call.args[0]);
+    if (call.args[0] === 'local' && !discovery && !state.flowId) return deny('Entrorove：本地执行前必须先受理原任务并绑定账号、flowId 与仓库；不能直接使用其它流程的通行证。');
+    if (state.pendingCall && !observer) return deny('Entrorove：原调用尚未收到结束回执；先只读恢复其状态，禁止并发重发。');
+    const input = call.args[0] === 'invoke' ? call.input?.input : call.input;
+    if (input?.flowId && state.flowId && input.flowId !== state.flowId || input?.taskId && state.taskId && ['cloud-watch','cloud-status'].includes(call.args[0]) && input.taskId !== state.taskId) return deny('Entrorove：调用与本 IDE 任务的原编号不一致。');
+    if (call.args[0] === 'scope-connect' && call.args[1] !== state.repositoryRoot
+      || call.args[0] === 'local' && (input?.repositoryRoot && input.repositoryRoot !== state.repositoryRoot || call.args[2] && call.args[2] !== state.repositoryRoot)) return deny('Entrorove：调用不能替换本任务的实际仓库。');
+    let requestId;
+    if (call.args[0] === 'invoke' && !call.input.operation.startsWith('cloud-')) {
+      const { buildInvocation } = await import(pathToFileURL(path.join(path.dirname(runtime.cli), 'remote-client.mjs')).href);
+      requestId = buildInvocation(call.input.operation, call.input.input).requestId;
+    }
+    const pending = { toolUseId: event.tool_use_id, inputDigest: ideDigest(call), command: call.args[0], ...(requestId ? { requestId } : {}) };
+    if (observer) {
+      state.readCalls ??= {};
+      if (Object.keys(state.readCalls).length >= 32) return deny('Entrorove：只读恢复尚未返回，请等待原调用。');
+      state.readCalls[event.tool_use_id] = pending;
+    } else state.pendingCall = pending;
+    const installation = call.args[0] === 'install' && parsed.words.some(word => ['npx','npx.cmd'].includes(word));
+    const rewritten = renderSdkCommand(call, runtime, state.sessionId);
+    return output('PreToolUse', { permissionDecision: 'allow', ...(installation ? {} : { updatedInput: { ...event.tool_input, command: rewritten,
+      ...(Object.hasOwn(event.tool_input ?? {}, 'cmd') ? { cmd: rewritten } : {}) } }), additionalContext: ideContext(state) });
+  }
+  if (!state.active) return {};
+  if (['exec','functions.exec'].includes(event.tool_name)) {
+    const current = await ideRuntime(home), code = typeof event.tool_input === 'string' ? event.tool_input : event.tool_input?.code;
+    return inspectIdeCodeMode(code, current) ? output('PreToolUse', { additionalContext: ideContext(state) }) : deny('Entrorove：代码模式含未批准的原生执行或动态工具输入；请使用原任务的受控入口。');
+  }
+  if (isShell && readCommand(parsed) || readTools.has(event.tool_name)) return output('PreToolUse', { additionalContext: ideContext(state) });
+  return deny(`Entrorove：已阻止原生 ${event.tool_name ?? 'unknown'} 调用。当前阶段 ${state.phase}${state.taskNumber ? `，云端任务 ${state.taskNumber}` : ''}。写入、删除、移动及不确定的终端操作必须使用原任务的 guarded-write／guarded-delete／guarded-move 或已批准的执行计划；门禁未通过不得改换执行器。`);
+}
+export async function runIdeHook(event, { home } = {}) {
+  return ideSession(event, async state => {
+    const name = event.hook_event_name;
+    if (name === 'UserPromptSubmit' && /^(?:(?:请)?(?:停止使用|退出)\s*\$?entrorove|(?:stop using|exit)\s+\$?entrorove)[.!。！]?$/iu.test((event.prompt ?? '').trim())) {
+      state.active = false; state.phase = 'user-exited';
+      return output(name, { additionalContext: '用户明确退出 Entrorove 管理；原任务仍保留，未验收、未评分为成功。' });
+    }
+    if (name === 'UserPromptSubmit' && /\bentrorove\b/iu.test(event.prompt ?? '')) {
+      state.active = true;
+      if (state.phase === 'ended') { delete state.flowId; delete state.taskId; delete state.taskNumber; delete state.requestId; state.phase = 'entry'; }
+    }
+    if (name === 'PreToolUse') return beforeTool(event, state, home);
+    const pendingRead = state.readCalls?.[event.tool_use_id];
+    if (name === 'PostToolUse' && state.active && (state.pendingCall?.toolUseId === event.tool_use_id || pendingRead)) {
+      const pending = pendingRead ?? state.pendingCall;
+      const recorded = await consumeIdeResults(event, state, pending, home);
+      const visible = parseIdeResults(event.tool_response);
+      const values = [...recorded, ...visible];
+      if (['install','configure','agreement'].includes(pending.command)) {
+        delete state.readCalls[event.tool_use_id];
+        const configured = values.some(value => pending.command === 'install' ? /^\d+\.\d+\.\d+$/u.test(value.version ?? '') && value.ide?.configured === true
+          : pending.command === 'configure' ? value.configured === true : value.accepted === true);
+        if (!state.flowId && !state.taskId && !state.pendingCall && configured) state.phase = 'setup';
+        return output(name, { additionalContext: ideContext(state) });
+      }
+      if (!values.length) {
+        if (pendingRead) { delete state.readCalls[event.tool_use_id]; return output(name, { additionalContext: ideContext(state) }); }
+        state.phase = 'unknown';
+        if (pending.requestId) state.requestId = pending.requestId;
+        return { ...output(name, { additionalContext: `${ideContext(state)}原请求结果未知，只能 GET 恢复其 requestId，禁止再次 POST。` }), systemMessage: 'Entrorove 原调用尚无可验证结果，已保留待恢复记录。' };
+      }
+      const expectedRequest = state.pendingCall?.requestId ?? state.remoteRequestId ?? state.requestId;
+      const bound = pendingRead ? values.filter(result => {
+        const value = result.output ?? result;
+        return value.requestId === expectedRequest || state.taskId && value.taskId === state.taskId;
+      }) : values;
+      const recoveredOriginal = pendingRead && state.pendingCall?.requestId
+        && values.some(result => (result.output ?? result).requestId === state.pendingCall.requestId);
+      const messages = collectResult(state, bound, pending.command === 'local');
+      if (pendingRead) delete state.readCalls[event.tool_use_id];
+      if (!pendingRead || recoveredOriginal) delete state.pendingCall;
+      return { ...output(name, { additionalContext: ideContext(state) }), ...(messages.length ? { systemMessage: messages.join('\n') } : {}) };
+    }
+    if (name === 'Stop' && state.active && !['ended','blocked','needs-input','setup'].includes(state.phase)) return { decision: 'block', reason: `${ideContext(state)}本轮没有取得原任务的结束回执，必须继续返回的操作或明确报告阻断原因。` };
+    return state.active && ['SessionStart','UserPromptSubmit','PostCompact','PreCompact'].includes(name) ? output(name, { additionalContext: ideContext(state) }) : {};
+  }, home);
+}
+let incomingEvent;
+async function main() {
+  let raw = '';
+  for await (const chunk of process.stdin) { raw += chunk; if (raw.length > 1_000_000) throw new Error('Host hook input is too large'); }
+  const event = JSON.parse(raw); incomingEvent = event.hook_event_name;
+  const result = await runIdeHook(event);
+  process.stdout.write(`${JSON.stringify(result)}\n`);
+}
+if (process.argv[1] && realpathSync(process.argv[1]) === fileURLToPath(import.meta.url)) main().catch(() => {
+  // A non-zero generic exit may fail open in the host. Always return a supported
+  // explicit denial, without including arguments, prompts, credentials or paths.
+  const reason = 'Entrorove 安全检查失败；本次工具调用已阻止，请修复原检查。';
+  const result = incomingEvent === 'Stop' ? { decision: 'block', reason } : incomingEvent === 'PreToolUse' ? deny(reason)
+    : { continue: false, stopReason: reason, systemMessage: reason };
+  process.stdout.write(`${JSON.stringify(result)}\n`);
+});

package/ide-install.mjs

@@ -0,0 +1,59 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { ideDirectory, ideDigest, readIdeJson, writeIdeJson, ideError } from './ide-session.mjs';
+import { withStateLock } from './local-state-lock.mjs';
+
+const source = path.dirname(fileURLToPath(import.meta.url));
+const files = ['ide-hook.mjs', 'ide-session.mjs', 'ide-results.mjs', 'ide-command.mjs', 'ide-code-mode.mjs', 'remote-transport.mjs', 'local-credential.mjs', 'local-state-lock.mjs'];
+const events = ['SessionStart', 'UserPromptSubmit', 'PreToolUse', 'PostToolUse', 'PostCompact', 'Stop'];
+const quote = text => `'${text.replace(/'/gu, "'\\''")}'`;
+function definition(node, file) {
+  const command = `${quote(node)} ${quote(file)}`;
+  return { hooks: Object.fromEntries(events.map(event => [event, [{ hooks: [{ type: 'command', command,
+    timeout: 10, statusMessage: 'Entrorove · 检查任务', additionalContextLimit: 1500 }] }]])) };
+}
+async function prepareConfigDirectory(home) {
+  const directory = path.join(home, '.codex');
+  await fs.mkdir(directory, { recursive: true, mode: 0o700 });
+  const stat = await fs.lstat(directory);
+  if (!stat.isDirectory() || stat.isSymbolicLink() || process.platform !== 'win32' && stat.uid !== process.getuid()) throw ideError('ENTROROVE_IDE_CONFIG', 'Codex config must be an owned real directory');
+  return directory;
+}
+function mergeHooks(existing, previous, current) {
+  if (existing && (typeof existing !== 'object' || Array.isArray(existing) || existing.hooks && typeof existing.hooks !== 'object')) throw ideError('ENTROROVE_IDE_CONFIG', 'Existing hooks config is invalid; it was preserved');
+  const next = { ...existing, hooks: { ...existing?.hooks } };
+  for (const event of events) {
+    const old = previous?.hooks?.[event]?.[0], entries = next.hooks[event] ?? [];
+    if (!Array.isArray(entries)) throw ideError('ENTROROVE_IDE_CONFIG', 'Existing hook list is invalid; it was preserved');
+    const ours = entries.filter(entry => old && JSON.stringify(entry) === JSON.stringify(old));
+    if (previous && !ours.length && entries.some(entry => entry.hooks?.some(hook => hook.command === old?.hooks?.[0]?.command))) throw ideError('ENTROROVE_IDE_CONFIG_EDITED', 'A hand-edited Entrorove hook was preserved; review it before updating');
+    next.hooks[event] = [...entries.filter(entry => !ours.includes(entry)), current.hooks[event][0]];
+  }
+  return next;
+}
+export async function installIdeHooks({ home, version, packageDirectory = source, node = process.execPath }) {
+  const directory = await ideDirectory(home, true), configDirectory = await prepareConfigDirectory(home);
+  const hooksPath = path.join(configDirectory, 'hooks.json'), recordPath = path.join(directory, 'installation.json');
+  return withStateLock(hooksPath, async () => {
+    const existing = await readIdeJson(hooksPath), previous = await readIdeJson(recordPath);
+    const current = definition(node, path.join(directory, 'ide-hook.mjs'));
+    const config = mergeHooks(existing, previous?.definition, current);
+    const contents = await Promise.all(files.map(async name => [name, await fs.readFile(path.join(source, name))]));
+    for (const [name, bytes] of contents) {
+      const target = path.join(directory, name), stat = await fs.lstat(target).catch(cause => { if (cause.code !== 'ENOENT') throw cause; return null; });
+      if (stat && (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1)) throw ideError('ENTROROVE_IDE_STORE', 'Managed hook target must be a private regular file');
+      if (stat && previous?.files?.[name] && ideDigest((await fs.readFile(target)).toString('utf8')) !== previous.files[name]) throw ideError('ENTROROVE_IDE_HOOK_EDITED', 'Hand-edited hook code was preserved');
+      await fs.writeFile(target, bytes, { mode: 0o600 });
+    }
+    const cli = path.join(packageDirectory, 'cli.mjs');
+    await writeIdeJson(path.join(directory, 'runtime.json'), { schemaVersion: 'entrorove.ide-runtime/1.0', version, node, cli,
+      apiOrigin: 'https://entrorove.com',
+      cliDigest: ideDigest((await fs.readFile(cli)).toString('utf8')) });
+    if (JSON.stringify(existing) !== JSON.stringify(config)) await writeIdeJson(hooksPath, config);
+    await writeIdeJson(recordPath, { schemaVersion: 'entrorove.ide-installation/1.0', version, definition: current,
+      files: Object.fromEntries(contents.map(([name, bytes]) => [name, ideDigest(bytes.toString('utf8'))])) });
+    return { host: 'Codex', configured: true, enforcement: 'review-required', hooksPath,
+      message: '已安装持续执行检查。请在 Codex /hooks 审查并信任 Entrorove；实际收到 PreToolUse 回调后才算拦截已生效。' };
+  });
+}

package/ide-presentation.mjs

@@ -7,6 +7,12 @@ export function ideClientHeaders(environment = process.env) {
   if (typeof ide !== 'string' || !/^[\p{L}\p{N} .+_-]{2,48}$/u.test(ide)) throw new Error('Invalid ENTROROVE_IDE client name');
   return { 'x-entrorove-ide': ide };
 }
+export function ideTaskIdentity(supplied, environment = process.env) {
+  if (environment.CODEX_THREAD_ID && supplied && supplied !== environment.CODEX_THREAD_ID) {
+    throw new Error('Cloud task must retain the actual Codex task identity');
+  }
+  return environment.CODEX_THREAD_ID ?? supplied;
+}
 export function displayIdeEvent(event, sink, notifications) {
   if (sink) sink(event);
   else process.stderr.write(`${event.message}\n${event.detail ? event.detail + '\n' : ''}`);

package/ide-results.mjs

@@ -0,0 +1,59 @@
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { ideDirectory, ideDigest, ideResultContext, readIdeJson, writeIdeJson } from './ide-session.mjs';
+
+export function parseIdeResults(response) {
+  const raw = typeof response === 'string' ? response : response?.output ?? response?.stdout ?? response?.aggregated_output
+    ?? response?.content?.filter(item => item.type === 'text').map(item => item.text).join('\n');
+  if (typeof raw !== 'string') return [];
+  return raw.split(/\r?\n/u).flatMap(line => {
+    try { const value = JSON.parse(line); return value && typeof value === 'object' ? [value] : []; }
+    catch { return []; }
+  });
+}
+function resultMetadata(value, depth = 0) {
+  if (!value || typeof value !== 'object' || depth > 3) return undefined;
+  const metadata = {};
+  for (const key of ['schemaVersion', 'requestId', 'flowId', 'status', 'taskId', 'taskNumber', 'taskStatus']) {
+    if (typeof value[key] === 'string' && value[key].length <= 200) metadata[key] = value[key];
+  }
+  for (const key of ['output', 'result']) if (value[key]) metadata[key] = resultMetadata(value[key], depth + 1);
+  for (const key of ['nextStep', 'nextAction']) if (typeof value[key]?.operation === 'string') metadata[key] = { operation: value[key].operation };
+  if (value.interaction) metadata.interaction = true;
+  if (Array.isArray(value.reports)) metadata.reports = value.reports.map(report => ({ verdict: report.verdict }));
+  if (value.feedback?.acknowledgement?.stored === true) metadata.feedback = { receiptId: value.feedback.receiptId, acknowledgement: { stored: true } };
+  return metadata;
+}
+const resultFile = (directory, sessionId, toolUseId) => path.join(directory, `result-${ideDigest({ sessionId, toolUseId })}.json`);
+export async function persistIdeResults(context, values) {
+  if (!context || !values.length) return;
+  const directory = await ideDirectory(context.home);
+  await writeIdeJson(resultFile(directory, context.sessionId, context.toolUseId), {
+    schemaVersion: 'entrorove.ide-result/1.0', sessionId: context.sessionId, repositoryRoot: context.repositoryRoot,
+    toolUseId: context.toolUseId, inputDigest: context.inputDigest, accountDigest: context.accountDigest,
+    values: values.map(value => resultMetadata(value)), createdAt: new Date().toISOString()
+  });
+}
+export async function consumeIdeResults(event, state, pending, home) {
+  const file = resultFile(await ideDirectory(home), state.sessionId, event.tool_use_id), proof = await readIdeJson(file);
+  if (!proof) return [];
+  if (proof.schemaVersion !== 'entrorove.ide-result/1.0' || proof.sessionId !== state.sessionId
+    || proof.repositoryRoot !== state.repositoryRoot || proof.toolUseId !== pending.toolUseId
+    || proof.inputDigest !== pending.inputDigest || proof.accountDigest !== state.accountDigest
+    || !Array.isArray(proof.values)) throw new Error('CLI completion does not belong to this approved call');
+  await fs.unlink(file);
+  return proof.values;
+}
+export function captureIdeResults() {
+  const original = process.stdout.write, chunks = [];
+  let size = 0;
+  process.stdout.write = function(chunk, ...rest) {
+    size += Buffer.byteLength(chunk);
+    if (size <= 8_000_000) chunks.push(Buffer.isBuffer(chunk) ? chunk.toString('utf8') : chunk);
+    return original.call(this, chunk, ...rest);
+  };
+  return async () => {
+    process.stdout.write = original;
+    if (size <= 8_000_000) await persistIdeResults(ideResultContext(), parseIdeResults(chunks.join('')));
+  };
+}

package/ide-session.mjs

@@ -0,0 +1,86 @@
+import { constants, promises as fs } from 'node:fs';
+import { createHash, randomUUID } from 'node:crypto';
+import os from 'node:os';
+import path from 'node:path';
+import { credentialDirectory, readCredential } from './local-credential.mjs';
+import { withStateLock } from './local-state-lock.mjs';
+import { requestTransport, parseTransportResponse } from './remote-transport.mjs';
+
+export const ideDigest = value => createHash('sha256').update(typeof value === 'string' ? value : JSON.stringify(value)).digest('hex');
+export const ideError = (code, message) => Object.assign(new Error(message), { code });
+let approvedResultContext;
+export const ideResultContext = () => approvedResultContext;
+export async function ideDirectory(home = os.homedir(), create = false) {
+  const parent = await credentialDirectory(home, create), directory = path.join(parent, 'ide');
+  if (create) await fs.mkdir(directory, { recursive: true, mode: 0o700 });
+  const stat = await fs.lstat(directory);
+  if (!stat.isDirectory() || stat.isSymbolicLink() || process.platform !== 'win32' && (stat.uid !== process.getuid() || stat.mode & 0o077)) throw ideError('ENTROROVE_IDE_STORE', 'IDE state must be an owned private directory');
+  return directory;
+}
+export async function readIdeJson(file) {
+  let handle;
+  try {
+    handle = await fs.open(file, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+    const stat = await handle.stat();
+    if (!stat.isFile() || stat.nlink !== 1 || stat.size > 1_000_000 || process.platform !== 'win32' && (stat.uid !== process.getuid() || stat.mode & 0o077)) throw ideError('ENTROROVE_IDE_STORE', 'IDE state is not a private regular file');
+    return JSON.parse(await handle.readFile('utf8'));
+  } catch (cause) { if (cause.code === 'ENOENT') return null; throw cause; }
+  finally { await handle?.close(); }
+}
+export async function writeIdeJson(file, value) {
+  const stage = `${file}.${randomUUID()}.tmp`;
+  await fs.writeFile(stage, `${JSON.stringify(value)}\n`, { flag: 'wx', mode: 0o600 });
+  try { await fs.rename(stage, file); } finally { await fs.rm(stage, { force: true }); }
+}
+export async function ideSession(event, action, home = os.homedir()) {
+  if (typeof event.session_id !== 'string' || !/^[A-Za-z0-9_-]{1,200}$/u.test(event.session_id) || !path.isAbsolute(event.cwd ?? '')) throw ideError('ENTROROVE_IDE_IDENTITY', 'Host hook requires its actual session and repository');
+  const directory = await ideDirectory(home, true), file = path.join(directory, `session-${ideDigest(event.session_id)}.json`);
+  return withStateLock(file, async () => {
+    const root = await fs.realpath(event.cwd), prior = await readIdeJson(file);
+    if (prior && (prior.schemaVersion !== 'entrorove.ide-session/1.0' || prior.sessionId !== event.session_id || prior.repositoryRoot !== root)) throw ideError('ENTROROVE_IDE_IDENTITY', 'A session cannot replace its original physical repository');
+    const state = prior ?? { schemaVersion: 'entrorove.ide-session/1.0', sessionId: event.session_id, repositoryRoot: root, active: false, phase: 'entry', seen: [] };
+    const result = await action(state);
+    await writeIdeJson(file, { ...state, observedAt: new Date().toISOString() });
+    return result;
+  });
+}
+export async function bindIdeAccount(state, home = os.homedir()) {
+  const token = await readCredential(home), digest = ideDigest(token);
+  if (state.accountDigest && state.accountDigest !== digest) {
+    const runtime = await ideRuntime(home);
+    const originalRequest = state.pendingCall?.requestId ?? state.remoteRequestId ?? state.requestId;
+    const route = state.taskId ? `/api/cloud-sandbox/tasks/${state.taskId}` : originalRequest ? `/api/skill/status/${originalRequest}` : null;
+    if (!route) throw ideError('ENTROROVE_IDE_ACCOUNT', 'Cannot prove the rotated key owns the original task');
+    const response = await requestTransport(runtime.apiOrigin ?? 'https://entrorove.com', route,
+      { headers: { authorization: `Bearer ${token}` }, timeoutMs: 5000 });
+    const value = parseTransportResponse(response, 'original account binding');
+    if (!response.ok || (state.taskId ? value.task?.id !== state.taskId : value.output?.requestId !== originalRequest
+      || state.flowId && value.output?.flowId !== state.flowId)) throw ideError('ENTROROVE_IDE_ACCOUNT', 'Account changed; the original task cannot inherit another account');
+  }
+  state.accountDigest = digest;
+}
+export async function ideRuntime(home = os.homedir()) {
+  const directory = await ideDirectory(home), runtime = await readIdeJson(path.join(directory, 'runtime.json'));
+  if (!runtime || runtime.schemaVersion !== 'entrorove.ide-runtime/1.0' || !path.isAbsolute(runtime.node ?? '') || !path.isAbsolute(runtime.cli ?? '') || !/^\d+\.\d+\.\d+$/u.test(runtime.version ?? '')) throw ideError('ENTROROVE_IDE_RUNTIME', 'Install the Entrorove IDE runtime before executing');
+  const cli = await fs.readFile(runtime.cli);
+  if (ideDigest(cli.toString('utf8')) !== runtime.cliDigest) throw ideError('ENTROROVE_IDE_RUNTIME', 'Installed CLI changed; reinstall the managed runtime');
+  return runtime;
+}
+export function ideContext(state) {
+  return `Entrorove 已强制接管本任务。${state.taskNumber ? `云端任务 ${state.taskNumber}。` : '尚未获得云端任务编号，不得声称已进入云端。'}${state.flowId ? `继续原 flowId=${state.flowId}，` : ''}${state.requestId ? `原 requestId=${state.requestId}。` : ''}当前阶段 ${state.phase}。必须读 SKILL.md 并执行返回的 nextStep；禁止在失败后替换执行器。源文件、数据及终端写入必须走原任务的受控入口。`;
+}
+export async function assertIdeExecution(args, input, { home = os.homedir(), environment = process.env } = {}) {
+  const host = environment.ENTROROVE_IDE ?? (environment.CODEX_THREAD_ID ? 'Codex' : environment.CURSOR_TRACE_ID ? 'Cursor' : environment.CLAUDE_CODE_ENTRYPOINT ? 'Claude Code' : null);
+  if (!host || host === 'Entrorove CLI') return;
+  if (host !== 'Codex' || !environment.CODEX_THREAD_ID) throw ideError('ENTROROVE_IDE_GUARD_UNSUPPORTED', 'This IDE has no verified tool guard adapter. Execution is blocked; never continue with another executor.');
+  const directory = await ideDirectory(home), state = await readIdeJson(path.join(directory, `session-${ideDigest(environment.CODEX_THREAD_ID)}.json`));
+  const expected = ideDigest({ args, input });
+  const approved = [state?.pendingCall, ...Object.values(state?.readCalls ?? {})].find(call => call?.inputDigest === expected);
+  if (!state?.active || !approved || state.sessionId !== environment.CODEX_THREAD_ID
+    || Date.now() - Date.parse(state.observedAt) > 120_000) {
+    throw ideError('ENTROROVE_IDE_GUARD_REQUIRED', 'Codex tool guard has not approved this exact call. Run install, review Entrorove in /hooks, and resume the original task.');
+  }
+  await bindIdeAccount(state, home);
+  approvedResultContext = { home, sessionId: state.sessionId, repositoryRoot: state.repositoryRoot,
+    accountDigest: state.accountDigest, toolUseId: approved.toolUseId, inputDigest: expected };
+}

package/local-approved-plan.mjs

@@ -6,6 +6,9 @@ import os from 'node:os';
 import path from 'node:path';
 import { performance } from 'node:perf_hooks';
 import { assertBudgetRunnerAllowed } from './local-budget-reads.mjs';
+import { validateRunnerParallelPaths, captureRunnerEquivalence } from './local-equivalence-runner.mjs';
+import { disciplineApprovedPolicy, disciplineDataSnapshotsBound } from './local-discipline-contracts.mjs';
+import { runnerDisciplineBefore, runnerDisciplineAfter } from './local-runner-discipline.mjs';
 
 export const RUNNER_SCHEMA = 'entrorove.validator-local-runner/1.0';
 export const PLAN_SCHEMA = 'validator.execution-plan/1.0';
@@ -33,7 +36,15 @@ function validatePlan(plan, artifactDigest = planArtifact) {
   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 (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');
+  const policy = exactObject(plan.policy, ['executable', 'executableSha256', 'args', 'environment', 'timeoutMs', 'maxOutputBytes', 'requiredExitCode',
+    ...['parallelPaths', 'discipline'].filter(key => Object.hasOwn(plan.policy, key))], 'execution policy');
+  validateRunnerParallelPaths(plan);
+  if (policy.discipline) {
+    const reviewed = disciplineApprovedPolicy(policy.discipline);
+    if (!disciplineDataSnapshotsBound(reviewed, plan.files)) {
+      fail('ENTROROVE_DISCIPLINE_DATA_SNAPSHOT_REQUIRED', 'Existing data operations require their actual frozen snapshot artifact before execution');
+    }
+  }
   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');
@@ -95,13 +106,16 @@ function runCommand(authority) {
     });
   });
 }
-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 } }; }
+async function subject(authority, result) {
+  const equivalence = await captureRunnerEquivalence(authority, result, projectFile);
+  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.policy.parallelPaths ? { parallelPaths: authority.plan.policy.parallelPaths } : {}), ...(authority.plan.policy.discipline ? { disciplineReviewRequired: true } : {}), ...(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 } : {}) } : {}) }, ...(equivalence === undefined ? {} : { equivalence }), ...(authority.disciplineComparison ? { disciplineComparison: authority.disciplineComparison } : {}), 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 async function runApprovedPlan(input) { const owner = await authority(input); const comparison = await runnerDisciplineBefore(input, owner); 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; }
+  owner.disciplineComparison = await runnerDisciplineAfter(comparison, owner);
+  const sub = await 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' };
 }
 
 async function objectAuthority(input, afterExecution = false) {
@@ -123,13 +137,14 @@ async function objectAuthority(input, afterExecution = false) {
 }
 
 export async function runApprovedPlanObject(input) {
-  const owner = await objectAuthority(input); const result = await runCommand(owner);
+  const owner = await objectAuthority(input); const comparison = await runnerDisciplineBefore(input, owner); 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);
+  owner.disciplineComparison = await runnerDisciplineAfter(comparison, owner);
+  const sub = await 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,

package/local-archguard-ast.mjs

@@ -285,8 +285,13 @@ function syntaxDiagnostics(source) {
     target: ts.ScriptTarget.Latest, jsx: ts.JsxEmit.Preserve }, host);
   return program.getSyntacticDiagnostics(source);
 }
+export function archguardScriptSource(file) {
+  const kind = SCRIPT_KINDS.get(file.path.split('.').at(-1));
+  if (kind === undefined) return null;
+  return ts.createSourceFile(file.path, file.content, ts.ScriptTarget.Latest, true, kind);
+}
 function analyzeScriptFile(file, rules) {
-  const source = ts.createSourceFile(file.path, file.content, ts.ScriptTarget.Latest, true, SCRIPT_KINDS.get(file.path.split('.').at(-1)));
+  const source = archguardScriptSource(file);
   const diagnostics = syntaxDiagnostics(source).map(diagnostic => {
     const at = source.getLineAndCharacterOfPosition(diagnostic.start ?? 0);
     return { code: diagnostic.code, start: diagnostic.start ?? 0, end: (diagnostic.start ?? 0) + (diagnostic.length ?? 0),

package/local-archguard-language-ast.mjs

@@ -7,6 +7,13 @@ const grammars = new Map();
 for (const language of ['css', 'python', 'java', 'rust']) {
   grammars.set(language, await Parser.Language.load(require.resolve(`tree-sitter-wasms/out/tree-sitter-${language}.wasm`)));
 }
+export async function withArchguardSyntaxTree(file, language, inspect) {
+  if (!['css','python','java','rust','php'].includes(language)) throw new Error('ARCH-AST-LANGUAGE-UNSUPPORTED');
+  if (!grammars.has(language)) grammars.set(language, await Parser.Language.load(require.resolve(`tree-sitter-wasms/out/tree-sitter-${language}.wasm`)));
+  const parser = new Parser(); parser.setLanguage(grammars.get(language));
+  const tree = parser.parse(file.content);
+  try { return inspect(tree.rootNode); } finally { tree.delete(); parser.delete(); }
+}
 const EXTENSIONS = new Map([['css', 'css'], ['wxss', 'css'], ['py', 'python'], ['java', 'java'], ['rs', 'rust']]);
 const ROOTS = { css: 'stylesheet', python: 'module', java: 'program', rust: 'source_file' };
 const FUNCTIONS = { css: [], python: ['function_definition', 'lambda'], java: ['method_declaration', 'constructor_declaration', 'lambda_expression'],

package/local-cli.mjs

@@ -23,6 +23,8 @@ import { LOCAL_BUDGET_TRANSITION_OPERATIONS } from './local-budget-transition.mj
 import { ARCHGUARD_LOCAL_OPERATIONS } from './local-archguard-operations.mjs';
 import { LOCAL_BUDGET_HANDOFF_OPERATIONS } from './local-budget-handoff.mjs';
 import { LOCAL_CHAIN_OPERATIONS } from './local-chain-operations.mjs';
+import { DISCIPLINE_LOCAL_OPERATIONS } from './local-discipline-operations.mjs';
+import { assertIdeExecution } from './ide-session.mjs';
 import { runManagedWorkflowLocalStep } from './workflow-local-client.mjs';
 import { localErrorEnvelope } from './local-error.mjs';
 
@@ -37,6 +39,7 @@ async function stdinJson() {
 }
 
 const operations = {
+  ...DISCIPLINE_LOCAL_OPERATIONS,
   'snapshot-plan': snapshotPlan, 'snapshot-verify': snapshotVerify, 'mutation-snapshot-attest': attestMutationSnapshot14, 'mutate-gate': mutateGate,
   'gate-issue': issueMutationPass, 'gate-verify': verifyMutationPass, 'guarded-write': guardedWrite,
   'budget-init': budgetInit, 'budget-context': budgetContext, 'budget-read': budgetRead, 'budget-status': budgetStatus,
@@ -76,7 +79,7 @@ function capabilitiesFor(group) {
 async function checkedLocalInput(operation, input) {
   try { return validateLocalInput(operation, input); }
   catch (cause) {
-    if (['guarded-write', 'gate-issue', 'mutate-gate', 'mutation-snapshot-attest'].includes(operation)) await recordMutationDenied14(input, cause, operation);
+    if (['guarded-write', 'guarded-delete', 'guarded-move', 'gate-issue', 'mutate-gate', 'mutation-snapshot-attest'].includes(operation)) await recordMutationDenied14(input, cause, operation);
     throw cause;
   }
 }
@@ -91,6 +94,7 @@ export async function runLocal(args = [], dependencies) {
     const handler = operations[operation];
     if (!handler) throw new Error(`Usage: entrorove local <${['capabilities', ...Object.keys(operations)].join('|')}> [repositoryRoot]`);
     const input = await stdinJson();
+    await assertIdeExecution(['local', ...args], input);
     if (args[1] && input.repositoryRoot === undefined) input.repositoryRoot = args[1];
     const validated = await checkedLocalInput(operation, input);
     const supplied = operation === 'workflow-run-step' || Object.hasOwn(LOCAL_CHAIN_OPERATIONS, operation) ? dependencies : undefined;
@@ -105,6 +109,7 @@ export async function runLocal(args = [], dependencies) {
 export async function runLocalInput(operation, input, dependencies) {
   if (operation === 'capabilities' || operation === 'help') { validateLocalInput(operation, input); return LOCAL_CAPABILITIES; }
   const handler = operations[operation];
+  await assertIdeExecution(['local', operation], input);
   if (!handler) throw new Error(`Unsupported local operation: ${operation}`);
   const validated = await checkedLocalInput(operation, input);
   const supplied = operation === 'workflow-run-step' || Object.hasOwn(LOCAL_CHAIN_OPERATIONS, operation) ? dependencies : undefined;

package/local-contracts.mjs

@@ -8,6 +8,7 @@ import { MERGE_LOCAL_OPERATION_SCHEMAS } from './local-merge-contracts.mjs';
 import { WORKFLOW_LOCAL_OPERATION_SCHEMA } from './workflow-local-contracts.mjs';
 import { HANDOFF_WRITE_PASS_SCHEMA, HANDOFF_PROVISIONAL_LEASE_SCHEMA, HANDOFF_SNAPSHOT_CANDIDATE_SCHEMA } from './local-task-handoff-contracts.mjs';
 import { LOCAL_CHAIN_OPERATION_SCHEMAS } from './local-chain-contracts.mjs';
+import { DISCIPLINE_DECLARATION_SCHEMA } from './local-discipline-contracts.mjs';
 import { array, binding, change, confirmation, enumeration, evidence, evidenceArray, executionContext, executionPlan,
   formula, formulaDefinitions, formulaEntry, decimalValues, identifier, integer, ledgerIdentifier, modes, nullable, object, paths, record, relativePath, sha256, text } from './local-contract-types.mjs';
 
@@ -31,7 +32,9 @@ add('mutation-snapshot-attest', { ...step, taskId: identifier, snapshotId: ident
   ['repositoryRoot', 'flowId', 'stepId', 'snapshotId', 'challenge', 'signerConfigPath']);
 const write = { ...step, taskId: identifier, generation: integer(1), executionAttemptNonce: identifier, gatePassPath: text, targetPath: relativePath, workerId: identifier, leaseId: identifier };
 add('gate-verify', write, ['repositoryRoot', 'flowId', 'stepId', 'gatePassPath', 'targetPath']);
-add('guarded-write', { ...write, content: {}, expectedSha256: nullable(sha256) }, ['repositoryRoot', 'flowId', 'stepId', 'gatePassPath', 'targetPath', 'content']);
+add('discipline-review|discipline-check', write, ['repositoryRoot', 'flowId', 'stepId', 'gatePassPath', 'targetPath']);
+add('guarded-delete|guarded-move', { ...write, declaration: DISCIPLINE_DECLARATION_SCHEMA }, ['repositoryRoot', 'flowId', 'stepId', 'gatePassPath', 'targetPath', 'declaration']);
+add('guarded-write', { ...write, content: {}, expectedSha256: nullable(sha256), declaration: DISCIPLINE_DECLARATION_SCHEMA }, ['repositoryRoot', 'flowId', 'stepId', 'gatePassPath', 'targetPath', 'content']);
 schemas['guarded-write'] = { oneOf: [schemas['guarded-write'], object({ ...step, targetPath: relativePath, content: {},
   expectedSha256: nullable(sha256), handoffId: ledgerIdentifier, epoch: integer(1, 2147483647),
   handoffPass: HANDOFF_WRITE_PASS_SCHEMA, provisionalLease: HANDOFF_PROVISIONAL_LEASE_SCHEMA },