@entrorove/skill 0.1.22 → 0.1.24

package/release.mjs

@@ -1,15 +1,127 @@
+import { FINAL_GATE16_PACKAGE_FILES, withFinalGate16ReleaseLabels } from './local-final-gate16-release.mjs'
 import { createHash } from 'node:crypto'
 import { readFile, writeFile, rename, rm } from 'node:fs/promises'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
 
 const directory = path.dirname(fileURLToPath(import.meta.url))
+const swarmSourceFiles = Object.freeze([
+  'local-swarm-authority.mjs',
+  'local-swarm-baseline.mjs',
+  'local-swarm-completion.mjs',
+  'local-swarm-contracts.mjs',
+  'local-swarm-mutation.mjs',
+  'local-swarm-priority.mjs',
+  'local-swarm-state.mjs',
+  'local-swarm-storage.mjs',
+  'local-swarm.mjs',
+])
 const sourceFiles = [
-  'cli.mjs', 'version.mjs', 'SKILL.md', 'CAPABILITY-MAP.md', 'AGREEMENT.md',
+  ...FINAL_GATE16_PACKAGE_FILES,
+  'local-merge-archguard-verification.d.mts',
+  'local-merge-archguard-verification.mjs',
+  'local-merge-archguard.mjs',
+  'local-merge-artifacts.mjs',
+  'local-merge-authority.mjs',
+  'local-merge-contracts.mjs',
+  'local-merge-controller.mjs',
+  'local-merge-head.mjs',
+  'local-merge-journal.mjs',
+  'local-merge-mutation.mjs',
+  'local-merge-rollback.mjs',
+  'local-merge-snapshot-rollback.mjs',
+  'local-merge-storage.mjs',
+  'local-merge-targets.mjs',
+  'local-merge-transaction.mjs',
+  ...swarmSourceFiles,
+  'cli.mjs', 'review-client.mjs', 'version.mjs', 'SKILL.md', 'CAPABILITY-MAP.md', 'AGREEMENT.md',
   'package.json', 'manifest.json', 'release.mjs',
-  'local-cli.mjs', 'local-state-lock.mjs', 'local-execution.mjs', 'local-integrity.mjs', 'local-formula.mjs', 'local-ledger.mjs',
+  'local-cli.mjs', 'local-state-lock.mjs', 'local-execution.mjs', 'local-integrity.mjs', 'local-evidence-verification.mjs', 'local-formula.mjs', 'local-ledger.mjs',
+  'blueprint-criterion-wire.mjs', 'blueprint-criterion-runner.mjs',
   'local-approved-plan.mjs', 'local-budget-renewal.mjs', 'local-probe.mjs',
+  'local-budget-grants.mjs', 'local-budget-handoff.mjs', 'local-budget-handoff-contracts.mjs', 'local-budget-lock.mjs',
+  'local-budget-handoff-completion.mjs',
+  'local-budget-reads.mjs', 'local-budget-source-bindings.mjs', 'local-budget-store.mjs',
+  'local-budget-transition.mjs', 'local-budget.mjs',
+  'local-scope-candidate.mjs',
+  'local-scope-context.mjs',
+  'local-scope-files.mjs',
+  'local-scope-repository.mjs',
+  'local-scope-git.mjs',
+  'local-scope-git-reads.mjs',
+  'local-scope-git-comparison.mjs',
+  'local-scope-git-attributes.mjs',
+  'local-scope-git-history.mjs',
+  'local-budget-git.mjs',
+  'local-budget-git-loader.mjs',
+  'local-budget-git-scratch.mjs',
+  'local-budget-git-scratch-loader.mjs',
+  'local-budget-git-attributes.mjs',
+  'local-budget-git-native-attributes.mjs',
+  'local-budget-git-native-reads.mjs',
+  'local-budget-git-native-request.mjs',
+  'local-budget-git-native-runtime.mjs',
+  'local-budget-git-native.mjs',
+  'local-budget-git-native.c',
+  'local-budget-git-native-linux.mjs',
+  'local-budget-git-native-darwin.mjs',
+  'local-budget-git-outcome.mjs',
+  'local-budget-git-system-attributes.mjs',
+  'runtime/git-native-linux-v1.mjs',
+  'runtime/git-native-darwin-v1.mjs',
+  'local-scope-signature.mjs',
+  'local-scope-snapshot.mjs',
+  'local-scope-state.mjs',
+  'local-scope-workspaces.mjs',
   'local-task-routing.mjs', 'remote-client.mjs',
+  'remote-transport.mjs', 'local-credential.mjs', 'local-invocations.mjs',
+  'local-task-handoff-fence.mjs',
+  'local-task-handoff-storage.mjs', 'local-task-handoff-overlay-wire.mjs', 'local-task-handoff-completion-wire.mjs',
+  'local-task-handoff-contracts.mjs',
+  'local-task-handoff-write-constraints.mjs',
+  'local-task-handoff-observation.mjs', 'local-task-handoff-write-wire.mjs',
+  'local-task-handoff-read-authority.mjs',
+  'local-task-handoff-write-archive.mjs', 'local-task-handoff-write-receipts.mjs',
+  'workflow-local-runner.mjs', 'workflow-local-contracts.mjs', 'workflow-local-client.mjs', 'workflow-local-request.mjs',
+  'task-message-entry.mjs', 'task-message-cli.mjs',
+  'local-contracts.mjs', 'local-contract-types.mjs',
+  'local-archguard-ast.mjs',
+  'local-archguard-checkpoint.mjs',
+  'local-archguard-components.mjs',
+  'local-archguard-contract.mjs',
+  'local-archguard-contracts.mjs',
+  'local-archguard-evaluate.mjs',
+  'local-archguard-language-ast.mjs',
+  'local-archguard-mutation-fence.mjs',
+  'local-archguard-operations.mjs',
+  'local-archguard-scope.mjs',
+  'local-archguard-signing.mjs',
+  'local-archguard-snapshot.mjs',
+  'local-archguard-state.mjs',
+  'local-archguard.mjs',
+  'archguard-runtime-build.mjs',
+  'runtime/archguard-runtime-v7.0.44.mjs',
+  'local-decimal.mjs',
+  'local-formula-ast.mjs',
+  'local-formula-engine.mjs',
+  'local-formula-tests.mjs',
+  'local-calctool.mjs',
+  'local-calctool-cli.mjs',
+  'local-calctool-contracts.mjs',
+  'local-calctool-runtime.mjs',
+  'local-calctool-storage.mjs',
+  'local-mutation-files.mjs',
+  'local-mutation-snapshot.mjs',
+  'local-mutation-audit.mjs',
+  'local-mutation-wire.mjs',
+  'local-mutation-binding.mjs',
+  'local-mutation-pass-store.mjs',
+  'local-mutation-authority.mjs',
+  'local-mutation-batch.mjs',
+  'local-mutation-batch-receipt.mjs',
+  'calctool-runtime-entry.mjs',
+  'calctool-runtime-build.mjs',
+  'runtime/calctool-runtime-v7.0.43.mjs',
 ]
 const stateFile = 'release-state.json'
 const changelogFile = 'CHANGELOG.md'
@@ -49,6 +161,63 @@ function versionNext(version) {
   return `${parts[0]}.${parts[1]}.${parts[2] + 1}`
 }
 
+const calctoolReleaseLabels = Object.freeze({
+  'local-decimal.mjs': { zh: 'Calctool Decimal28 公式与本地执行', en: 'Calctool Decimal28 formulas and local execution' },
+  'local-formula-ast.mjs': { zh: 'Calctool Decimal28 公式与本地执行', en: 'Calctool Decimal28 formulas and local execution' },
+  'local-formula-engine.mjs': { zh: 'Calctool Decimal28 公式与本地执行', en: 'Calctool Decimal28 formulas and local execution' },
+  'local-formula-tests.mjs': { zh: 'Calctool Decimal28 公式与本地执行', en: 'Calctool Decimal28 formulas and local execution' },
+  'local-calctool.mjs': { zh: 'Calctool Decimal28 公式与本地执行', en: 'Calctool Decimal28 formulas and local execution' },
+  'local-calctool-cli.mjs': { zh: 'Calctool Decimal28 公式与本地执行', en: 'Calctool Decimal28 formulas and local execution' },
+  'local-calctool-contracts.mjs': { zh: 'Calctool Decimal28 公式与本地执行', en: 'Calctool Decimal28 formulas and local execution' },
+  'local-calctool-runtime.mjs': { zh: 'Calctool Decimal28 公式与本地执行', en: 'Calctool Decimal28 formulas and local execution' },
+  'local-calctool-storage.mjs': { zh: 'Calctool Decimal28 公式与本地执行', en: 'Calctool Decimal28 formulas and local execution' },
+  'calctool-runtime-entry.mjs': { zh: 'Calctool Decimal28 公式与本地执行', en: 'Calctool Decimal28 formulas and local execution' },
+  'calctool-runtime-build.mjs': { zh: 'Calctool Decimal28 公式与本地执行', en: 'Calctool Decimal28 formulas and local execution' },
+  'runtime/calctool-runtime-v7.0.43.mjs': { zh: 'Calctool Decimal28 公式与本地执行', en: 'Calctool Decimal28 formulas and local execution' },
+})
+
+const mutationReleaseLabels = Object.freeze({
+  'local-mutation-files.mjs': { zh: '原任务短时写入授权与文件快照隔离', en: 'Original task short-lived mutation authority and file snapshot isolation' },
+  'local-mutation-snapshot.mjs': { zh: '原任务短时写入授权与文件快照隔离', en: 'Original task short-lived mutation authority and file snapshot isolation' },
+  'local-mutation-audit.mjs': { zh: '原任务短时写入授权与文件快照隔离', en: 'Original task short-lived mutation authority and file snapshot isolation' },
+  'local-mutation-wire.mjs': { zh: '原任务短时写入授权与文件快照隔离', en: 'Original task short-lived mutation authority and file snapshot isolation' },
+  'local-mutation-binding.mjs': { zh: '原任务短时写入授权与文件快照隔离', en: 'Original task short-lived mutation authority and file snapshot isolation' },
+  'local-mutation-pass-store.mjs': { zh: '原任务短时写入授权与文件快照隔离', en: 'Original task short-lived mutation authority and file snapshot isolation' },
+  'local-mutation-authority.mjs': { zh: '原任务短时写入授权与文件快照隔离', en: 'Original task short-lived mutation authority and file snapshot isolation' },
+  'local-mutation-batch.mjs': { zh: '原任务批量写入消费与失败审计', en: 'Original task batch mutation consumption and failure audit' },
+  'local-mutation-batch-receipt.mjs': { zh: '原注册执行端批量消费签名回执', en: 'Registered runner signed batch consumption receipts' },
+})
+
+const swarmReleaseLabels = Object.freeze(Object.fromEntries(swarmSourceFiles.map(name => [name, {
+  zh: 'Swarm 原授权协作调度与实际执行守卫', en: 'Swarm original-authority coordination and actual execution guard',
+}])))
+
+const nativeReadReleaseLabels = {
+  'local-budget-git-attributes.mjs': { zh: '固定Git实际源读取与预算记账', en: 'fixed Git actual source reads and budget accounting' },
+  'local-budget-git-native-attributes.mjs': { zh: '固定Git实际源读取与预算记账', en: 'fixed Git actual source reads and budget accounting' },
+  'local-budget-git-native-reads.mjs': { zh: '固定Git实际源读取与预算记账', en: 'fixed Git actual source reads and budget accounting' },
+  'local-budget-git-native-request.mjs': { zh: '固定Git实际源读取与预算记账', en: 'fixed Git actual source reads and budget accounting' },
+  'local-budget-git-native-runtime.mjs': { zh: '固定Git实际源读取与预算记账', en: 'fixed Git actual source reads and budget accounting' },
+  'local-budget-git-native.mjs': { zh: '固定Git实际源读取与预算记账', en: 'fixed Git actual source reads and budget accounting' },
+  'local-budget-git-native.c': { zh: '固定Git实际源读取与预算记账', en: 'fixed Git actual source reads and budget accounting' },
+  'local-budget-git-native-linux.mjs': { zh: '固定Git实际源读取与预算记账', en: 'fixed Git actual source reads and budget accounting' },
+  'local-budget-git-native-darwin.mjs': { zh: '固定Git实际源读取与预算记账', en: 'fixed Git actual source reads and budget accounting' },
+  'local-budget-git-outcome.mjs': { zh: '固定Git实际源读取与预算记账', en: 'fixed Git actual source reads and budget accounting' },
+  'local-budget-git-system-attributes.mjs': { zh: '固定Git实际源读取与预算记账', en: 'fixed Git actual source reads and budget accounting' },
+  'runtime/git-native-linux-v1.mjs': { zh: '固定Git实际源读取与预算记账', en: 'fixed Git actual source reads and budget accounting' },
+  'runtime/git-native-darwin-v1.mjs': { zh: '固定Git实际源读取与预算记账', en: 'fixed Git actual source reads and budget accounting' },
+}
+
+const feedbackReleaseLabels = Object.freeze({
+  'review-client.mjs': { zh: '真实成功调用反馈绑定与明确公开同意', en: 'actual successful invocation feedback binding and explicit public consent' },
+})
+
+const invocationReleaseLabels = {
+  'remote-transport.mjs': { zh: '真实网络阶段与原请求恢复', en: 'Actual network phases and original request recovery' },
+  'local-credential.mjs': { zh: '唯一私有凭据与原子轮换', en: 'Single private credential and atomic rotation' },
+  'local-invocations.mjs': { zh: '无明文调用台账与用量对账', en: 'Metadata invocation ledger and usage reconciliation' },
+}
+
 function releaseNote(changed) {
   const suppliedZh = process.env.ENTROROVE_RELEASE_NOTE_ZH?.trim()
   const suppliedEn = process.env.ENTROROVE_RELEASE_NOTE_EN?.trim()
@@ -58,7 +227,25 @@ function releaseNote(changed) {
   if (suppliedZh && suppliedEn) return {
     zh: suppliedZh.replaceAll(/\s+/g, ' '), en: suppliedEn.replaceAll(/\s+/g, ' '),
   }
-  const labels = {
+  const labels = withFinalGate16ReleaseLabels({ ...calctoolReleaseLabels, ...mutationReleaseLabels, ...swarmReleaseLabels, ...nativeReadReleaseLabels, ...feedbackReleaseLabels, ...invocationReleaseLabels,
+    'blueprint-criterion-wire.mjs': { zh: '蓝图验收标准执行授权', en: 'Blueprint criterion execution authority' },
+    'blueprint-criterion-runner.mjs': { zh: '蓝图验收标准实际执行器', en: 'Blueprint criterion process runner' },
+    'local-archguard-ast.mjs': { zh: 'Archguard 架构合同与执行守卫', en: 'Archguard architecture contract and execution guard' },
+    'local-archguard-checkpoint.mjs': { zh: 'Archguard 架构合同与执行守卫', en: 'Archguard architecture contract and execution guard' },
+    'local-archguard-components.mjs': { zh: 'Archguard 架构合同与执行守卫', en: 'Archguard architecture contract and execution guard' },
+    'local-archguard-contract.mjs': { zh: 'Archguard 架构合同与执行守卫', en: 'Archguard architecture contract and execution guard' },
+    'local-archguard-contracts.mjs': { zh: 'Archguard 架构合同与执行守卫', en: 'Archguard architecture contract and execution guard' },
+    'local-archguard-evaluate.mjs': { zh: 'Archguard 架构合同与执行守卫', en: 'Archguard architecture contract and execution guard' },
+    'local-archguard-language-ast.mjs': { zh: 'Archguard 架构合同与执行守卫', en: 'Archguard architecture contract and execution guard' },
+    'local-archguard-mutation-fence.mjs': { zh: 'Archguard 架构合同与执行守卫', en: 'Archguard architecture contract and execution guard' },
+    'local-archguard-operations.mjs': { zh: 'Archguard 架构合同与执行守卫', en: 'Archguard architecture contract and execution guard' },
+    'local-archguard-scope.mjs': { zh: 'Archguard 架构合同与执行守卫', en: 'Archguard architecture contract and execution guard' },
+    'local-archguard-signing.mjs': { zh: 'Archguard 架构合同与执行守卫', en: 'Archguard architecture contract and execution guard' },
+    'local-archguard-snapshot.mjs': { zh: 'Archguard 架构合同与执行守卫', en: 'Archguard architecture contract and execution guard' },
+    'local-archguard-state.mjs': { zh: 'Archguard 架构合同与执行守卫', en: 'Archguard architecture contract and execution guard' },
+    'local-archguard.mjs': { zh: 'Archguard 架构合同与执行守卫', en: 'Archguard architecture contract and execution guard' },
+    'archguard-runtime-build.mjs': { zh: 'Archguard 架构合同与执行守卫', en: 'Archguard architecture contract and execution guard' },
+    'runtime/archguard-runtime-v7.0.44.mjs': { zh: 'Archguard 架构合同与执行守卫', en: 'Archguard architecture contract and execution guard' },
     'cli.mjs': { zh: '技能运行和受管安装', en: 'skill runtime and managed installation' },
     'version.mjs': { zh: '版本安全检查', en: 'version safety checks' },
     'SKILL.md': { zh: 'IDE 工作流程说明', en: 'IDE workflow instructions' },
@@ -68,17 +255,64 @@ function releaseNote(changed) {
     'manifest.json': { zh: '技能清单', en: 'skill manifest' },
     'release.mjs': { zh: '自动版本与更新日志', en: 'automatic versioning and changelog' },
     'local-cli.mjs': { zh: '本地执行命令', en: 'local execution command' },
+    'local-contracts.mjs': { zh: '本地操作契约与输入验证', en: 'local operation contracts and input validation' },
+    'local-contract-types.mjs': { zh: '共享执行数据契约', en: 'shared execution data contracts' },
     'local-state-lock.mjs': { zh: '本地状态并发锁', en: 'local state concurrency lock' },
     'local-execution.mjs': { zh: '本地执行闸门与预算', en: 'local execution gates and budgets' },
     'local-integrity.mjs': { zh: '证据与回执验签', en: 'evidence and receipt verification' },
+    'local-evidence-verification.mjs': { zh: 'Validator 独立证据验证与执行结果绑定', en: 'Validator independent evidence verification and execution result binding' },
     'local-formula.mjs': { zh: '确定性公式引擎', en: 'deterministic formula engine' },
     'local-ledger.mjs': { zh: '执行与链路台账', en: 'execution and chain ledger' },
     'local-approved-plan.mjs': { zh: '冻结计划执行器', en: 'frozen plan runner' },
     'local-budget-renewal.mjs': { zh: '预算续期确认', en: 'budget renewal confirmation' },
+    'local-budget-grants.mjs': { zh: '预算签名授权与原任务绑定', en: 'signed budget grants and original task binding' },
+    'local-budget-handoff.mjs': { zh: '交接读取权限与连续预算恢复', en: 'handoff read authority and continuous budget restoration' },
+    'local-budget-handoff-completion.mjs': { zh: '交接完成证明与读取授权', en: 'handoff completion proof and read authority' },
+    'local-budget-handoff-contracts.mjs': { zh: '交接预算输入契约', en: 'handoff budget input contracts' },
+    'local-budget-lock.mjs': { zh: '预算并发锁与崩溃恢复', en: 'budget concurrency lock and crash recovery' },
+    'local-budget-reads.mjs': { zh: '预算读取上下文与受控适配', en: 'budget read context and controlled adapters' },
+    'local-budget-source-bindings.mjs': { zh: '源文件与快照缓存路径绑定', en: 'source and snapshot cache path binding' },
+    'local-budget-store.mjs': { zh: '预算追加台账和完整性校验', en: 'budget append-only journal and integrity checks' },
+    'local-budget-transition.mjs': { zh: '候选范围与正式范围预算转换', en: 'candidate and accepted scope budget transition' },
+    'local-budget.mjs': { zh: '本地三轴读取预算', en: 'local three-axis read budgets' },
     'local-probe.mjs': { zh: '范围探测与分档', en: 'scope probing and tiering' },
+    'local-scope-candidate.mjs': { zh: '临时接管范围独立验签', en: 'temporary takeover scope verification' },
+    'local-scope-context.mjs': { zh: '精确符号范围绑定', en: 'exact symbol scope binding' },
+    'local-scope-files.mjs': { zh: '范围文件与安全读取', en: 'scope files and guarded reads' },
+    'local-scope-repository.mjs': { zh: '真实仓库范围事实', en: 'actual repository scope facts' },
+    'local-scope-git.mjs': { zh: '实际Git范围与变更事实', en: 'actual Git scope and change facts' },
+    'local-scope-git-reads.mjs': { zh: '固定Git元数据与源码读取', en: 'fixed Git metadata and source reads' },
+    'local-scope-git-comparison.mjs': { zh: 'Git范围比较接线', en: 'Git scope comparison wiring' },
+    'local-scope-git-attributes.mjs': { zh: 'Git属性读取与语义保留', en: 'Git attribute reads and semantics' },
+    'local-scope-git-history.mjs': { zh: '实际Git历史变更统计', en: 'actual Git history change statistics' },
+    'local-budget-git.mjs': { zh: 'Git源码读取预算', en: 'Git source read budgets' },
+    'local-budget-git-loader.mjs': { zh: '固定Git源码加载与校验', en: 'fixed Git source loading and validation' },
+    'local-budget-git-scratch.mjs': { zh: 'Git比较副本读取预算', en: 'Git comparison copy read budgets' },
+    'local-budget-git-scratch-loader.mjs': { zh: '固定Git比较副本与执行', en: 'fixed Git comparison copies and execution' },
+    'local-scope-signature.mjs': { zh: '新鲜范围回执签名', en: 'fresh scope receipt signing' },
+    'local-scope-snapshot.mjs': { zh: '范围快照与原副本校验', en: 'scope snapshots and original copy validation' },
+    'local-scope-state.mjs': { zh: '原范围历史与逐级重估', en: 'original scope history and incremental reassessment' },
+    'local-scope-workspaces.mjs': { zh: '实际workspace元数据', en: 'actual workspace metadata' },
     'local-task-routing.mjs': { zh: '本地任务路由', en: 'local task routing' },
+    'local-task-handoff-fence.mjs': { zh: '任务安全交接与撤权', en: 'task safe handoff and revocation' },
+    'local-task-handoff-storage.mjs': { zh: '任务交接可信存储', en: 'task handoff trusted storage' },
+    'local-task-handoff-overlay-wire.mjs': { zh: '任务接管范围凭据', en: 'task takeover scope receipts' },
+    'local-task-handoff-completion-wire.mjs': { zh: '任务接管完成凭据', en: 'task takeover completion receipts' },
+    'local-task-handoff-contracts.mjs': { zh: '任务交接本地调用契约', en: 'task handoff local invocation contracts' },
+    'local-task-handoff-write-constraints.mjs': { zh: '接管继承范围与架构约束', en: 'takeover inherited scope and architecture constraints' },
+    'local-task-handoff-observation.mjs': { zh: '接管受信本地观察', en: 'trusted local handoff observation' },
+    'local-task-handoff-read-authority.mjs': { zh: '临时读取授权与原目录绑定', en: 'temporary read authority and original home binding' },
+    'local-task-handoff-write-wire.mjs': { zh: '接管写入凭证契约', en: 'handoff write receipt contracts' },
+    'local-task-handoff-write-archive.mjs': { zh: '接管完整写入历史', en: 'complete handoff write history' },
+    'local-task-handoff-write-receipts.mjs': { zh: '接管实际写入凭证', en: 'actual handoff write receipts' },
+    'workflow-local-runner.mjs': { zh: '工作流原租约业务执行', en: 'workflow original lease business execution' },
+    'workflow-local-contracts.mjs': { zh: '工作流本地调用契约', en: 'workflow local invocation contracts' },
+    'workflow-local-client.mjs': { zh: '工作流真实执行授权', en: 'workflow actual execution authorization' },
+    'workflow-local-request.mjs': { zh: '工作流原执行请求恢复', en: 'workflow original execution request recovery' },
     'remote-client.mjs': { zh: '远端恢复客户端', en: 'remote recovery client' },
-  }
+    'task-message-entry.mjs': { zh: '任务消息实际投递入口', en: 'task message host delivery entry' },
+    'task-message-cli.mjs': { zh: '任务消息命令与适配器', en: 'task message command and adapter' },
+  })
   return {
     zh: `更新了${changed.map(name => labels[name].zh).join('、')}。`,
     en: `Updated ${changed.map(name => labels[name].en).join(', ')}.`,

package/releases.json

@@ -1,4 +1,16 @@
 [
+  {
+    "version": "0.1.24",
+    "date": "2026-10-07",
+    "zh": "更新已验收能力并完成发布前校验。",
+    "en": "Updated accepted capabilities and completed release preflight validation."
+  },
+  {
+    "version": "0.1.23",
+    "date": "2026-10-06",
+    "zh": "修复受管安装漏装能力映射文档的问题；旧安装自动补齐，用户编辑仍受保护。",
+    "en": "Fixed the missing capability map in managed installations; older installations are repaired while user edits remain protected."
+  },
   {
     "version": "0.1.22",
     "date": "2026-10-04",

package/remote-client.mjs

@@ -1,4 +1,7 @@
 import { createHash } from 'node:crypto';
+import Ajv from 'ajv';
+import { parseTransportResponse, requestTransport, trustedOrigin } from './remote-transport.mjs';
+import { appendInvocation } from './local-invocations.mjs';
 
 export const apiUrl = 'https://entrorove.com/api/skill/invoke';
 
@@ -15,33 +18,28 @@ function requestId(operation, input) {
 }
 
 export function buildInvocation(operation, input) {
-  if (!['capabilities', 'task-describe', 'message-route', 'message-accept', 'task-resume', 'start', 'continue'].includes(operation)) throw new Error('Invalid entrorove operation');
+  if (!['capabilities', 'task-describe', 'message-route', 'message-accept', 'task-resume', 'task-checkpoint',
+    'message-status', 'message-delivery-start', 'message-delivery-report', 'message-resolve', 'message-complete',
+    'handoff-prepare', 'handoff-release', 'handoff-claim', 'handoff-status', 'handoff-resume', 'handoff-execution-authority', 'mutation-snapshot-challenge', 'mutation-pass-issue',
+    'start', 'continue'].includes(operation)) throw new Error('Invalid entrorove operation');
   if (!input || typeof input !== 'object' || Array.isArray(input)) throw new Error('Input must be a JSON object');
   const id = requestId(operation, input);
   return { url: apiUrl, requestId: id, body: { schemaVersion: 'entrorove.skill.request/2.0', requestId: id, operation, input } };
 }
 
-async function readResponse(response, label) {
-  try { return await response.json(); } catch { throw new Error(`Invalid ${label} response`); }
+export function validateDiscoveredChecks(input, checks = []) {
+  for (const check of checks) {
+    if (check.kind !== 'unique-property' || typeof check.path !== 'string' || typeof check.property !== 'string') throw new Error('Unsupported capability input check');
+    const value = check.path.split('.').reduce((current, key) => current?.[key], input);
+    if (value === undefined) continue;
+    if (!Array.isArray(value) || new Set(value.map(item => item?.[check.property])).size !== value.length) throw new Error(`Invalid input: ${check.path} requires unique ${check.property} values`);
+  }
 }
 
-function preTlsRetryable(error) {
-  const code = error?.cause?.code ?? error?.code;
-  return ['ECONNRESET', 'ECONNREFUSED', 'EAI_AGAIN', 'ENETUNREACH', 'ENETDOWN',
-    'EHOSTUNREACH', 'ETIMEDOUT', 'ECONNABORTED', 'UND_ERR_CONNECT_TIMEOUT'].includes(code);
-}
+async function readResponse(response, label) { return parseTransportResponse(response, label); }
 
-async function readOnlyGet(url, headers, label) {
-  let last;
-  for (let attempt = 0; attempt < 3; attempt += 1) {
-    try {
-      return await fetch(url, { method: 'GET', redirect: 'error', signal: AbortSignal.timeout(15_000), headers });
-    } catch (error) {
-      last = error;
-      if (!preTlsRetryable(error) || attempt === 2) break;
-    }
-  }
-  throw new Error(`Unable to read ${label}; ${last instanceof Error ? last.message : 'network error'}`);
+async function readOnlyGet(origin, pathname, headers) {
+  return requestTransport(origin, pathname, { headers });
 }
 
 export async function invokeRemote(data, dependencies) {
@@ -52,39 +50,132 @@ export async function invokeRemote(data, dependencies) {
     process.exitCode = 2;
     return;
   }
-  const call = buildInvocation(data.operation, data.input);
+  const call = { ...buildInvocation(data.operation, data.input), url: `${trustedOrigin(apiOrigin())}/api/skill/invoke` };
   const token = await readCredential(home);
-  let response;
-  try {
-    response = await fetch(call.url, {
-      method: 'POST', redirect: 'error', signal: AbortSignal.timeout(135_000),
-      headers: { 'content-type': 'application/json', authorization: `Bearer ${token}` },
-      body: JSON.stringify(call.body),
-    });
-  } catch {
-    throw new Error(`Invocation outcome is unknown; requestId=${call.requestId}. Do not automatically resend this request.`);
-  }
-  const result = await readResponse(response, 'invocation');
-  if (!result || !result.output || result.output.requestId !== call.requestId) {
-    throw new Error(`Invalid entrorove response; requestId=${call.requestId}`);
+  if (data.operation !== 'capabilities') {
+    const discovery = await postInvocation({ ...buildInvocation('capabilities', {}), url: call.url }, token, home);
+    if (!discovery.response.ok || discovery.result.output.status !== 'succeeded') throw new Error(`Capability discovery failed: HTTP ${discovery.response.status}`);
+    const capabilities = discovery.result.output.capabilities;
+    const schema = capabilities?.operationSchemas?.[data.operation];
+    if (!capabilities?.operations?.includes(data.operation) || !schema) throw new Error(`Capability discovery does not support ${data.operation}`);
+    const validate = new Ajv({ strict: true, strictRequired: false, allErrors: true }).compile(schema);
+    if (!validate(data.input)) throw new Error(`Invalid ${data.operation} input: ${validate.errors.map(error => `${error.instancePath || '/'} ${error.message}`).join('; ')}`);
+    validateDiscoveredChecks(data.input, capabilities.inputChecks?.[data.operation]);
   }
+  const { response, result } = await postInvocation(call, token, home);
   process.stdout.write(JSON.stringify(result) + '\n');
   if (!response.ok || result.output.status === 'blocked' || result.output.status === 'failed'
     || result.output.status === 'incomplete') process.exitCode = 2;
 }
 
+async function postInvocation(call, token, home) {
+  const metadata = { kind: 'remote', operation: call.body.operation, requestId: call.requestId };
+  const logged = async value => {
+    try { return await appendInvocation({ ...metadata, ...value }, home); }
+    catch { throw unknownInvocation(call.requestId); }
+  };
+  await appendInvocation({ ...metadata, event: 'started' }, home);
+  let response; let result;
+  try {
+    response = await requestTransport(new URL(call.url).origin, '/api/skill/invoke', {
+      method: 'POST', timeoutMs: 135_000,
+      headers: { 'content-type': 'application/json', authorization: `Bearer ${token}` }, body: JSON.stringify(call.body),
+    });
+  } catch (cause) {
+    if (cause.established) await logged({ event: 'outcome-unknown' });
+    else await appendInvocation({ ...metadata, event: 'not-sent' }, home);
+    if (cause.established) throw unknownInvocation(call.requestId);
+    throw Object.assign(new Error(`Entrorove request was not sent; connection failed after ${cause.attempts ?? 1} attempt(s); requestId=${call.requestId}`),
+      { requestId: call.requestId, retryableBeforeTransmission: Boolean(cause.retryableBeforeTransmission), attempts: cause.attempts ?? 1 });
+  }
+  try { result = await readResponse(response, 'invocation'); } catch {
+    await logged({ event: 'outcome-unknown' }); throw unknownInvocation(call.requestId);
+  }
+  if (!response.ok && !result?.output) {
+    await logged({ event: response.status >= 500 ? 'outcome-unknown' : 'rejected' });
+    if (response.status >= 500) throw unknownInvocation(call.requestId);
+    const code = typeof result?.error === 'string' && /^[a-z][a-z0-9-]{0,63}$/.test(result.error) ? result.error : 'request-rejected';
+    throw new Error(`entrorove invocation failed: HTTP ${response.status}; ${code}; requestId=${call.requestId}`);
+  }
+  if (!result?.output || result.output.requestId !== call.requestId) {
+    await logged({ event: 'outcome-unknown' }); throw unknownInvocation(call.requestId);
+  }
+  await logged({ event: response.ok ? 'completed' : 'rejected', usage: result.usage ?? [] });
+  return { response, result };
+}
+
+function unknownInvocation(requestId) {
+  return Object.assign(new Error(`Invocation outcome is unknown; requestId=${requestId}. Do not automatically resend this request.`),
+    { requestId, outcomeUnknown: true });
+}
+async function machineCredential(dependencies) {
+  await dependencies.install();
+  if (!await dependencies.agreementAccepted(dependencies.home)) {
+    throw Object.assign(new Error('Entrorove agreement requires explicit acceptance before task message communication'),
+      { interaction: dependencies.agreementRequired(dependencies.home) });
+  }
+  return dependencies.readCredential(dependencies.home);
+}
+function machineOrigin(dependencies) { return trustedOrigin(dependencies.apiOrigin()); }
+function validateMachineCapability(operation, input, capabilities) {
+  const schema = capabilities?.operationSchemas?.[operation];
+  if (!capabilities?.operations?.includes(operation) || !schema) throw new Error(`Capability discovery does not support ${operation}`);
+  const validate = new Ajv({ strict: true, strictRequired: false, allErrors: true }).compile(schema);
+  if (!validate(input)) throw new Error(`Invalid ${operation} input: ${validate.errors.map(error => `${error.instancePath || '/'} ${error.message}`).join('; ')}`);
+  validateDiscoveredChecks(input, capabilities.inputChecks?.[operation]);
+}
+function stoppedOriginalResume(response, output, operation, input) {
+  return operation === 'task-resume' && response.status === 422 && output?.schemaVersion === 'entrorove.skill.response/1.0'
+    && output.status === 'blocked' && output.canContinue === false && typeof output.task?.taskId === 'string'
+    && Boolean(input.taskId || input.flowId) && (!input.taskId || output.task.taskId === input.taskId)
+    && (!input.flowId || output.task.flowId === input.flowId && output.flowId === input.flowId);
+}
+export function createTaskMessageClient(dependencies) {
+  if (!dependencies || !['install', 'agreementAccepted', 'agreementRequired', 'readCredential', 'apiOrigin']
+    .every(key => typeof dependencies[key] === 'function')) throw new Error('Task message client requires its installed credential and agreement dependencies');
+  return {
+    async invoke(operation, input) {
+      const original = buildInvocation(operation, input);
+      const token = await machineCredential(dependencies); const origin = machineOrigin(dependencies);
+      if (operation !== 'capabilities') {
+        const discovery = buildInvocation('capabilities', {});
+        const discovered = await postInvocation({ ...discovery, url: `${origin}/api/skill/invoke` }, token, dependencies.home);
+        if (!discovered.response.ok || discovered.result.output.status !== 'succeeded') throw new Error('Task message capability discovery failed');
+        validateMachineCapability(operation, input, discovered.result.output.capabilities);
+      }
+      const { response, result } = await postInvocation({ ...original, url: `${origin}/api/skill/invoke` }, token, dependencies.home);
+      if (stoppedOriginalResume(response, result.output, operation, input)) return result.output;
+      if (!response.ok || ['blocked', 'failed', 'incomplete'].includes(result.output.status)) {
+        throw new Error(`Task message invocation was rejected: HTTP ${response.status}; requestId=${original.requestId}`);
+      }
+      return result.output;
+    },
+    async status(id) {
+      if (typeof id !== 'string' || !/^[a-f0-9]{64}$/.test(id)) throw new Error('Task message status requires its original sha256 requestId');
+      const token = await machineCredential(dependencies);
+      const response = await readOnlyGet(machineOrigin(dependencies), `/api/skill/status/${id}`,
+        { authorization: `Bearer ${token}` }, 'original task message status');
+      const result = await readResponse(response, 'task message status');
+      if (!response.ok || !result?.output || result.output.requestId !== id) throw new Error('Original task message status is unavailable or invalid');
+      await appendInvocation({ kind: 'remote', operation: 'status', requestId: id, event: 'status', usage: result.usage ?? [] }, dependencies.home);
+      return result.output;
+    },
+  };
+}
+
 export async function queryStatus(requestId, dependencies) {
   if (typeof requestId !== 'string' || !/^[a-f0-9]{64}$/.test(requestId)) throw new Error('status requires a sha256 requestId');
   const token = await dependencies.readCredential(dependencies.home);
-  const response = await readOnlyGet(`${dependencies.apiOrigin()}/api/skill/status/${encodeURIComponent(requestId)}`, { authorization: `Bearer ${token}` }, 'status')
+  const response = await readOnlyGet(dependencies.apiOrigin(), `/api/skill/status/${encodeURIComponent(requestId)}`, { authorization: `Bearer ${token}` }, 'status')
   const result = await readResponse(response, 'status');
-  if (!response.ok) throw new Error(`entrorove status failed: HTTP ${response.status}; requestId=${requestId}`);
+  if (!response.ok || result?.output?.requestId !== requestId) throw new Error(`entrorove status failed: HTTP ${response.status}; requestId=${requestId}`);
+  await appendInvocation({ kind: 'remote', operation: 'status', requestId, event: 'status', usage: result.usage ?? [] }, dependencies.home);
   process.stdout.write(JSON.stringify(result) + '\n');
 }
 
 export async function queryFlows(dependencies) {
   const token = await dependencies.readCredential(dependencies.home);
-  const response = await readOnlyGet(`${dependencies.apiOrigin()}/api/skill/flows`, { authorization: `Bearer ${token}` }, 'flow list')
+  const response = await readOnlyGet(dependencies.apiOrigin(), '/api/skill/flows', { authorization: `Bearer ${token}` }, 'flow list')
   const result = await readResponse(response, 'flow list');
   if (!response.ok) throw new Error(`entrorove flow list failed: HTTP ${response.status}`);
   process.stdout.write(JSON.stringify(result) + '\n');

package/remote-transport.mjs

@@ -0,0 +1,80 @@
+import http from 'node:http';
+import https from 'node:https';
+
+const PRE_CONNECT = new Set(['ECONNREFUSED', 'ECONNRESET', 'EAI_AGAIN', 'ENOTFOUND', 'ENETUNREACH',
+  'ENETDOWN', 'EHOSTUNREACH', 'ETIMEDOUT', 'ECONNABORTED']);
+const MAX_BYTES = 1_048_576;
+
+export function trustedOrigin(value) {
+  let url;
+  try { url = new URL(value); } catch { throw new Error('Invalid Entrorove API origin'); }
+  if (url.username || url.password || url.search || url.hash || url.pathname !== '/'
+    || url.protocol !== 'https:' && !(url.protocol === 'http:' && ['127.0.0.1', 'localhost', '[::1]'].includes(url.hostname))) {
+    throw new Error('Entrorove API requires HTTPS or an owned loopback listener');
+  }
+  return url.origin;
+}
+
+function failure(code, established) {
+  return Object.assign(new Error(established ? 'Entrorove response was interrupted after connection establishment'
+    : 'Entrorove connection failed before request transmission'), {
+    code: 'ENTROROVE_TRANSPORT', established, retryableBeforeTransmission: !established && PRE_CONNECT.has(code),
+    transportCode: PRE_CONNECT.has(code) ? code : 'CONNECTION_REJECTED',
+  });
+}
+
+async function attempt(url, options) {
+  return new Promise((resolve, reject) => {
+    let established = false; let settled = false;
+    const done = (cause, result) => {
+      if (settled) return; settled = true; clearTimeout(timer);
+      if (cause) reject(failure(cause.code, established)); else resolve(result);
+    };
+    const client = url.protocol === 'https:' ? https : http;
+    const request = client.request(url, { method: options.method, headers: options.headers,
+      agent: false }, response => {
+      established = true; const chunks = []; let size = 0;
+      response.on('data', chunk => {
+        size += chunk.length;
+        if (size > MAX_BYTES) { done({ code: 'RESPONSE_TOO_LARGE' }); response.destroy(); request.destroy(); }
+        else chunks.push(chunk);
+      });
+      response.on('aborted', () => done({ code: 'RESPONSE_INTERRUPTED' }));
+      response.on('error', cause => done(cause));
+      response.on('end', () => done(null, { ok: response.statusCode >= 200 && response.statusCode < 300,
+        status: response.statusCode, headers: response.headers, body: Buffer.concat(chunks).toString('utf8') }));
+    });
+    request.on('socket', socket => {
+      socket.once(url.protocol === 'https:' ? 'secureConnect' : 'connect', () => { established = true; });
+    });
+    request.on('error', cause => done(cause));
+    const timer = setTimeout(() => { done({ code: 'ETIMEDOUT' }); request.destroy(); }, options.timeoutMs);
+    request.end(options.body);
+  });
+}
+
+export async function requestTransport(origin, pathname, options = {}) {
+  const trusted = trustedOrigin(origin);
+  if (typeof pathname !== 'string' || !pathname.startsWith('/api/') || pathname.includes('://')) throw new Error('Invalid Entrorove API path');
+  const url = new URL(pathname, trusted);
+  if (url.origin !== trusted || url.search || url.hash) throw new Error('Invalid Entrorove API path');
+  const configured = { timeoutMs: 15_000, method: 'GET', ...options };
+  if (!['GET', 'POST'].includes(configured.method)) throw new Error('Invalid Entrorove transport method');
+  for (let number = 1; number <= 3; number++) {
+    try {
+      const response = await attempt(url, configured);
+      if (response.status >= 300 && response.status < 400) {
+        throw Object.assign(new Error('Entrorove API redirects are refused'), { code: 'ENTROROVE_REDIRECT', established: true });
+      }
+      return { ...response, attempts: number };
+    } catch (cause) {
+      cause.attempts = number;
+      if (!cause.retryableBeforeTransmission || number === 3) throw cause;
+    }
+  }
+}
+
+export function parseTransportResponse(response, label = 'Entrorove') {
+  try { return JSON.parse(response.body); }
+  catch { throw Object.assign(new Error(`Invalid ${label} response`), { code: 'ENTROROVE_RESPONSE_INVALID' }); }
+}