@entrorove/skill 0.1.31 → 0.1.33

package/CAPABILITY-MAP.md

@@ -36,6 +36,8 @@ Entrorove 只治理通过技能入口执行的动作：路径、通行证、快
 
 ## 本地基线（当前 `LOCAL_OPERATION_SCHEMAS` 100 项）
 
+`scope-connect <absolute repositoryRoot>` 是 CLI 编排入口，不改变这 100 项本地操作。它串联远端 `scope-runner-prepare/register/challenge/attest` 与已有真实快照、签名检查，为原账号与任务提交范围证据；不授予执行证据签名或写入权限。全部远端操作以实时 discovery 为准。
+
 | 分区 | 精确操作名 | 证据位置 |
 | --- | --- | --- |
 | 核心 discovery、快照、门控、预算、协调、证据、链、任务路由（54） | `capabilities`, `help`, `snapshot-plan`, `snapshot-verify`, `mutate-gate`, `gate-issue`, `mutation-snapshot-attest`, `gate-verify`, `guarded-write`, `budget-init`, `budget-handoff`, `budget-context`, `budget-read`, `budget-status`, `budget-extend`, `budget-transition`, `peer-coordinate`, `coordinate`, `spawn-bind`, `peer-complete`, `complete`, `lease-verify`, `evidence-sign`, `evidence-verify`, `rollback`, `final-gate`, `formula-evaluate`, `formula-graph`, `formula-final-gate`, `calculation-final-gate`, `run-approved-plan`, `branch-create`, `branch-create-virtual`, `branch-list`, `branch-switch`, `diff-report`, `preflight`, `ledger-query`, `chain-ledger-query`, `chain-init`, `chain-ledger-init`, `chain-resume`, `chain-status`, `chain-ledger-status`, `chain-answer`, `budget-auto-renew-request`, `budget-auto-renew`, `budget-auto-renew-stop`, `probe`, `reassess`, `task-describe`, `message-route`, `message-accept`, `task-resume` | `packages/entrorove-skill/local-contracts.mjs:14-114` |

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.1.33 — 2026-10-12
+
+- 补齐账号与任务隔离的本地签名器和真实快照接入，解析实际别名及类型声明；动态依赖仅进入受限规划，保留独立写入核验。
+- Connected account-bound scope signers and real snapshots, resolved actual aliases and declarations, and retained restricted planning for unresolved dynamic imports with separate mutation verification.
+
+## 0.1.32 — 2026-10-11
+
+- 增加云端沙箱状态与用量只读查询，并支持按任务直接读取真实状态。
+- Added read-only cloud sandbox status and direct reads of authoritative task state and usage.
+
 ## 0.1.31 — 2026-10-11
 
 - 修复云端沙箱任务响应处理并保留可继续的任务上下文。

package/SKILL.md

@@ -5,7 +5,7 @@ description: An engineering skill that understands a task, chooses a fitting wor
 
 # entrorove · 熵巡
 
-Version: 0.1.31.
+Version: 0.1.33.
 
 Read the user's goal and repository instructions first. Preserve the original task through planning, execution and verification. Use the workflow only where it helps; a small, low-risk edit can proceed directly. Never claim a reported step is a verified result.
 
@@ -25,11 +25,13 @@ On first use or after a material agreement revision, the CLI returns a Confirm P
 
 Send JSON on standard input to `npx @entrorove/skill invoke`. Before every execution call, discover `operation: "capabilities"` with `{}` and validate input against the returned operation schema. The CLI performs remote discovery automatically; local adapters discover the installed contract before execution. Discovery failure stops execution. Adapters that expose the four-step task route can call `task-describe`, `message-route`, `message-accept` and `task-resume` in order; `start` remains the one-call workflow equivalent. Then start with `operation: "start"` and an `input.task` containing the goal, work type, risk, difficulty and observed scope facts. Work types are `implementation`, `documentation`, `calculation`, `merge`, `review`, `decision` and `diagnosis`. Assess facts from the real task and repository; do not invent certainty. entrorove chooses the workflow. A small task may return `decision: "direct"`, meaning the IDE should do the work without another service call. The public envelope is `entrorove.skill.request/2.0`; `requestId` is the SHA-256 digest of `operation + canonical(input)`. Version 1.0 remains accepted for older callers.
 
-`start` creates a normal durable skill flow. It does not create a cloud-sandbox task or contribute to cloud-sandbox usage. To create a real cloud-sandbox task, call `operation: "cloud-task"` with `input.goal`; the CLI returns a Confirm Protocol choice interaction before any cloud request. Continue the same request with `sandboxChoice: "use"` or `sandboxChoice: "local"`. `use` calls the authenticated `/api/cloud-task` endpoint and returns the real `taskId`; `local` skips only this task. A `needs-input`, `blocked` or `failed` result is not a successful dispatch and must be shown to the user.
+`start` creates a normal durable skill flow. It does not create a cloud-sandbox task or contribute to cloud-sandbox usage. To create a real cloud-sandbox task, call `operation: "cloud-task"` with `input.goal`; the CLI returns a Confirm Protocol choice interaction before any cloud request. Continue the same request with `sandboxChoice: "use"` or `sandboxChoice: "local"`. `use` calls the authenticated `/api/cloud-task` endpoint and returns the real `taskId`; `local` skips only this task. The server is authoritative for account entitlement and the account-wide sandbox preference: a disabled or unavailable account returns `blocked` and creates no task. A `needs-input`, `blocked` or `failed` result is not a successful dispatch and must be shown to the user.
+
+After dispatch, query the real task without resending it with the CLI-only `operation: "cloud-status"` and `input.taskId`, or `npx @entrorove/skill cloud-status` with the same JSON. This special CLI route reads the authoritative task list and usage endpoints; it is not part of the `/api/skill/invoke` capability map. The read-only result includes the current task status, public title/summary, and recorded model usage when available. A missing task is reported explicitly; it is never treated as completed. This is the skill-side status and usage check for cloud tasks; the web dock may additionally subscribe to its event stream.
 
 ### Per-task cloud sandbox choice
 
-When the host exposes an enabled cloud-sandbox preference and a new task is about to dispatch a cloud model, ask once whether this task should use the cloud sandbox. This is a low-risk routing preference, separate from agreement acceptance and the medium/high-risk confirmations below. Offer `use for this task` and `continue locally`; if the user gives no answer, use the cloud sandbox by the host's stated timeout default. An explicit opt-out applies only to the current task and must not change the account-wide sandbox preference. Do not ask again while continuing or resuming the same task. If the account-wide preference is disabled or unavailable, do not dispatch a cloud task and do not show a misleading per-task prompt; preserve the normal local workflow and report the prerequisite clearly. This choice never bypasses the normal task schema, mutation authority, evidence checks, or risk confirmation.
+When the host exposes an enabled cloud-sandbox preference and a new task is about to dispatch a cloud model, ask once whether this task should use the cloud sandbox. This is a low-risk routing preference, separate from agreement acceptance and the medium/high-risk confirmations below. Offer `use for this task` and `continue locally`; if the user gives no answer, continue locally. Cloud submission requires an explicit choice or the user’s existing authorization for this task; silence never authorizes cloud consumption. An explicit opt-out applies only to the current task and must not change the account-wide sandbox preference. Do not ask again while continuing or resuming the same task. If the host cannot preflight the account preference, show the choice only as a routing decision and let the server's authoritative `/api/cloud-task` check return a clear `blocked` prerequisite; never claim that a task started after a blocked response. This choice never bypasses the normal task schema, mutation authority, evidence checks, or risk confirmation.
 
 ```json
 {"operation":"start","input":{"task":{"goal":"Update the checkout flow and verify it","workType":"implementation","risk":"medium","difficulty":"medium","crossModule":true,"parallel":false,"unclear":false,"architectureContract":false}}}
@@ -43,13 +45,19 @@ For a returned `flowId`, continue with `{"operation":"continue","input":{"flowId
 
 The v2 progress sequence is durable and ordered: the first runtime step reports `intake`, then the applicability `gate` is recorded and verified, then the selected contract or plan steps run. Every step can be `pending`, `running`, `reported`, `verified`, `blocked` or `failed`; only a completed verdict with trusted evidence is green.
 
+When intake returns `workflow-gate`, connect the current repository before invoking that gate: run `npx @entrorove/skill scope-connect <absolute repositoryRoot>` with JSON `{"flowId":"<original flowId>","paths":["<existing source file>"]}` on stdin. Use the concrete existing source files in the task's scope; new files belong in the later plan's declared artifacts. The adapter enrolls an OS-private Ed25519 scope signer for this accepted account and task, answers a server challenge, copies and verifies real source files, and submits the signed facts. It sends hashes and scope metadata rather than source contents or the private key. Enrollment grants scope inspection only; execution evidence and write passes retain their separate authority checks. An operator-configured signer cannot be replaced. After a successful connection, invoke the original `workflow-gate` with the same paths. Refresh an expired snapshot by reconnecting the same flow and path set. Show an explicit blocked result; query the original request ID after an unknown transport outcome before considering another attempt.
+
+Scope inspection resolves aliases from actual `tsconfig.json` or `jsconfig.json`, including relative `extends`. For plugin source compiled by a host project whose config is outside the source's ancestors, include `importContexts: [{"sourcePrefix":"<plugin source directory>","configPath":"<actual host tsconfig.json>"}]` in `scope-connect` input. Inspect the real build configuration first; never invent an alias or mark an unresolved import as external. These context paths remain inside the repository, their hashes enter the signed facts, and the local task binding freezes them.
+
+Computed runtime imports remain explicitly unresolved with their actual source paths and hashes. A member's scope-only signer may submit these observations to enter restricted planning; the cloud returns `planningOnly: true` and `requires-complete-import-graph-before-mutation`. Do not treat this as full dependency verification, execution permission, or business completion. Resolve the dynamic dependency contract and obtain complete verified facts before mutation; never set `complete` manually or replace the original signer or paths to bypass the restriction.
+
 For a decision, include `input.task.interaction` with `type` (`confirm`, `choice`, `multi` or `input`), a `question`, `options` (two or more with unique `id` and `label`, or an empty array for input), and a `callback` containing its `operation` and `payload`. Medium- and high-risk decisions also need a `riskDescription`. The decision waits for an explicit answer; it never chooses a default on timeout.
 
 Use `npx @entrorove/skill status <requestId>` after a connection loss. It performs a read-only GET lookup and never resends a POST. Use `npx @entrorove/skill flows` to list recoverable flow steps. A v2 flow has its own `flowId` and progresses through `pending`, `running`, `reported`, `verified`, `blocked` or `failed`; a reported result is not a verified result.
 
-The local execution layer is available through `npx @entrorove/skill local <operation> [repositoryRoot]` with a JSON object on standard input. `local capabilities` lists the complete contract. Operations include `snapshot-plan`, `snapshot-verify`, `mutate-gate`, `gate-issue`, `gate-verify`, `guarded-write`, `budget-init`, `budget-context`, `budget-read`, `budget-status`, `budget-extend`, budget renewal confirmation, `peer-coordinate`, `spawn-bind`, `peer-complete`, `lease-verify`, `probe`, `reassess`, execution ledger and virtual branch records, `chain-init`, `chain-resume`, `chain-status`, `chain-answer`, `evidence-sign`, `evidence-verify`, `merge-verified`, `rollback`, `formula-evaluate`, `formula-graph`, `formula-final-gate`, `run-approved-plan` and `final-gate`. State is kept only under `~/.entrorove/`; snapshots never create Git branches or worktrees. Guarded writes require a short-lived Ed25519 pass bound to the flow, step, snapshot digest and path set. Local evidence uses `entrorove.test-evidence/2.0`; unsigned local evidence remains incomplete and verified delivery requires a trusted receipt. Approved plan execution requires a frozen plan, matching approval and unchanged files; without a configured runner signer it reports local evidence as incomplete.
+The local execution layer is available through `npx @entrorove/skill local <operation> [repositoryRoot]` with a JSON object on standard input. `local capabilities` lists the complete contract, operation groups and `requiresPass` metadata. `local capabilities <group>` filters that same contract. Operations include `snapshot-plan`, `snapshot-verify`, `mutate-gate`, `gate-issue`, `gate-verify`, `guarded-write`, `budget-init`, `budget-context`, `budget-read`, `budget-status`, `budget-extend`, budget renewal confirmation, `peer-coordinate`, `spawn-bind`, `peer-complete`, `lease-verify`, `probe`, `reassess`, execution ledger and virtual branch records, `chain-init`, `chain-resume`, `chain-status`, `chain-answer`, `evidence-sign`, `evidence-verify`, `merge-verified`, `rollback`, `formula-evaluate`, `formula-graph`, `formula-final-gate`, `run-approved-plan` and `final-gate`. State is kept only under `~/.entrorove/`; snapshots never create Git branches or worktrees. Guarded writes require a short-lived Ed25519 pass bound to the flow, step, snapshot digest and path set. Local evidence uses `entrorove.test-evidence/2.0`; unsigned local evidence remains incomplete and verified delivery requires a trusted receipt. Approved plan execution requires a frozen plan, matching approval and unchanged files; without a configured runner signer it reports local evidence as incomplete.
 
-Local CLI failures use the machine-readable `entrorove.local-error/1.0` envelope `{schemaVersion,status,code,message}` on stderr. `status` is `failed` for invalid input or computation errors and `blocked` for missing mutation, lease, snapshot or handoff authority. Formula `add` and `mul` require at least one argument; `div`, `safeDivide` and `percentOf` reject a zero denominator with `DIV_ZERO`. The formula engine declares `round` as half-away-from-zero with two decimal places by default; an engine may declare another `decimalPlaces` value from 0 through 28 in its `roundingPolicy`.
+Local CLI failures use the machine-readable `entrorove.local-error/1.0` envelope `{schemaVersion,status,code,disposition,message}` on stderr. `status` is `failed` for invalid input or computation errors and `blocked` for missing mutation, lease, snapshot or handoff authority. Formula `add` and `mul` require at least one argument; `div`, `safeDivide` and `percentOf` reject a zero denominator with `DIV_ZERO`. The formula engine declares `round` as half-away-from-zero with two decimal places by default; an engine may declare another `decimalPlaces` value from 0 through 28 in its `roundingPolicy`.
 
 When the user gives an actual evaluation after using the skill, offer to publish that feedback. Only after they explicitly agree to public display under the current notice, send their unchanged words, IDE name and 1–5 rating as JSON on standard input to `npx @entrorove/skill review`, including `invocationRequestId` from their actual successful call, `publicConsent: true` and `noticeVersion: "2026-10-07.1"`. The same account must own that successful call within the last 30 days; a recorded usage event, failed call or unknown result does not qualify. Three public reviews per account per day share one server quota across API replicas. Public output exposes only IDE, rating, original text and time, never account or invocation identity. Never invent, rewrite or infer a review from task completion. The website reads accepted reviews directly from entrorove's independent database.
 
@@ -58,3 +66,5 @@ Feedback command example (replace the request ID with the original successful in
 ```json
 {"invocationRequestId":"<original successful request ID>","ide":"Codex","rating":5,"comment":"<unchanged user words>","publicConsent":true,"noticeVersion":"2026-10-07.1"}
 ```
+
+The fixed Git byte-metering adapter ships hash-pinned precompiled libraries for Darwin and glibc Linux on arm64/x64. It extracts the selected library on first use; it never invokes a C compiler on the user machine. Darwin requires Apple’s trusted Git (Xcode or Command Line Tools), xcrun and codesign; Linux requires the trusted `/usr/bin/git` and glibc. Missing or unsupported tools return `ENTROROVE_GIT_READER_UNSUPPORTED` explicitly and do not fall back to unmetered source reads.

package/cli.mjs

@@ -9,10 +9,11 @@ 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 { runScopeConnect } from './scope-runner-client.mjs';
 import { apiUrl, buildInvocation, invokeRemote, queryFlows, queryStatus } from './remote-client.mjs';
 const packageDir = path.dirname(fileURLToPath(import.meta.url));
 import { buildReview, submitSkillFeedback, feedbackNoticeVersion } from './review-client.mjs';
-import { runCloudTask as dispatchCloudTask } from './cloud-task-client.mjs';
+import { queryCloudTask, runCloudTask as dispatchCloudTask } from './cloud-task-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';
@@ -389,10 +390,20 @@ export async function runCloudTask(input, dependencies = remoteDependencies()) {
   return result;
 }
 
+export async function runCloudStatus(input, dependencies = remoteDependencies()) {
+  const result = await queryCloudTask(input?.taskId, dependencies);
+  process.stdout.write(`${JSON.stringify(result)}\n`);
+  if (['blocked', 'failed', 'missing'].includes(result.status)) process.exitCode = 2;
+  return result;
+}
+
 async function invoke(data) {
   if (data?.operation === 'cloud-task') {
     return runCloudTask(data.input, remoteDependencies());
   }
+  if (data?.operation === 'cloud-status') {
+    return runCloudStatus(data.input, remoteDependencies());
+  }
   return invokeRemote(data, remoteDependencies());
 }
 
@@ -419,10 +430,16 @@ 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 === 'scope-connect' && args.length === 1) {
+    const result = await runScopeConnect(args[0], await stdinJson(), remoteDependencies());
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+    if (result.status !== 'succeeded') process.exitCode = 2;
   } else if (command === 'host-message') {
     await runTaskMessageCli(args, await stdinJson(), remoteDependencies());
   } else if (command === 'cloud-task' && args.length === 0) {
     await runCloudTask(await stdinJson());
+  } else if (command === 'cloud-status' && args.length === 0) {
+    await runCloudStatus(await stdinJson());
   } else if (command === 'review' && args.length === 0) {
     await submitReview(await stdinJson());
   } else if (command === 'status' && args.length === 1) {
@@ -444,7 +461,7 @@ async function main() {
   } else if (command === 'local') {
     await runLocal(args);
   } else {
-    throw new Error('Usage: entrorove install | configure | agreement | invoke | host-message [adapterModulePath] | cloud-task | status <requestId> | flows | review | local (JSON on stdin)');
+    throw new Error('Usage: entrorove install | configure | agreement | invoke | scope-connect <repositoryRoot> | host-message [adapterModulePath] | cloud-task | cloud-status | status <requestId> | flows | review | local (JSON on stdin)');
   }
 }
 if (process.argv[1] && realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url))) {

package/cloud-task-client.mjs

@@ -3,6 +3,7 @@ import { appendInvocation } from './local-invocations.mjs';
 import { parseTransportResponse, requestTransport, trustedOrigin } from './remote-transport.mjs';
 
 const CLOUD_TASK_SCHEMA = 'entrorove.cloud-task/1.0';
+const CLOUD_STATUS_SCHEMA = 'entrorove.cloud-status/1.0';
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 
 function canonical(value) {
@@ -38,6 +39,15 @@ function validateDependencies(dependencies) {
   }
 }
 
+function validateTaskId(taskId) {
+  if (typeof taskId !== 'string' || !UUID.test(taskId)) throw new Error('cloud-status taskId must be a UUID');
+  return taskId;
+}
+
+function authenticatedHeaders(token, headers = {}) {
+  return { ...headers, authorization: `Bearer ${token}` };
+}
+
 export function sandboxChoiceInteraction(id) {
   return {
     schemaVersion: 'confirm.interaction/1.0', requestId: id, type: 'choice',
@@ -46,7 +56,7 @@ export function sandboxChoiceInteraction(id) {
       { id: 'use', label: '本任务使用云端沙箱', hint: '创建真实云端任务并持续记录进度' },
       { id: 'local', label: '继续本地执行', hint: '仅当前任务退出云端沙箱' },
     ],
-    default: 'use', timeout: 8_000, timeoutAction: 'use', risk: 'low',
+    default: 'local', timeout: 8_000, timeoutAction: 'local', risk: 'low',
     riskDescription: '这是当前任务的执行位置选择，不改变账号级云端沙箱开关。',
     rememberable: false, memoryKey: '',
     callback: { operation: 'cloud-task', payload: { sandboxChoice: 'use' } },
@@ -83,7 +93,7 @@ export async function runCloudTask(input, dependencies) {
   try {
     response = await requestTransport(origin, '/api/cloud-task', {
       method: 'POST', timeoutMs: 30_000,
-      headers: { 'content-type': 'application/json', authorization: `Bearer ${token}` },
+      headers: authenticatedHeaders(token, { 'content-type': 'application/json' }),
       body: JSON.stringify(task),
     });
   } catch (cause) {
@@ -117,3 +127,53 @@ export async function runCloudTask(input, dependencies) {
     executionIsolation: typeof result.executionIsolation === 'string' ? result.executionIsolation : 'worker' });
 }
 
+function publicTask(task) {
+  if (!task || typeof task !== 'object' || Array.isArray(task)) return null;
+  const allowed = ['id', 'status', 'displayTitle', 'titleStatus', 'titleError', 'summary', 'ideTaskId',
+    'createdAt', 'updatedAt', 'completedAt'];
+  return Object.fromEntries(allowed.filter(key => task[key] !== undefined).map(key => [key, task[key]]));
+}
+
+function publicUsage(value) {
+  if (!Array.isArray(value)) return [];
+  const allowed = ['usageId', 'requestId', 'operation', 'attempt', 'meterKind', 'state', 'tokenStatus',
+    'inputTokens', 'outputTokens', 'durationMs', 'durationBasis', 'providerId', 'modelId'];
+  return value.filter(item => item && typeof item === 'object' && !Array.isArray(item))
+    .map(item => Object.fromEntries(allowed.filter(key => item[key] !== undefined).map(key => [key, item[key]])));
+}
+
+export async function queryCloudTask(taskId, dependencies) {
+  const id = validateTaskId(taskId);
+  validateDependencies(dependencies);
+  await dependencies.install();
+  if (!await dependencies.agreementAccepted(dependencies.home)) {
+    return { schemaVersion: CLOUD_STATUS_SCHEMA, status: 'blocked', taskId: id,
+      code: 'agreement-required', interaction: dependencies.agreementRequired(dependencies.home) };
+  }
+  const token = await dependencies.readCredential(dependencies.home);
+  const origin = trustedOrigin(dependencies.apiOrigin());
+  const metadata = { kind: 'remote', operation: 'cloud-status', requestId: requestId({ taskId: id }) };
+  const taskResponse = await requestTransport(origin, `/api/cloud-sandbox/tasks/${id}`, { headers: authenticatedHeaders(token) });
+  let taskBody;
+  try { taskBody = await responseBody(taskResponse); } catch { taskBody = null; }
+  if (!taskResponse.ok || !taskBody?.task || taskBody.task.id !== id) {
+    await appendInvocation({ ...metadata, event: 'rejected' }, dependencies.home);
+    return { schemaVersion: CLOUD_STATUS_SCHEMA, status: taskResponse.status === 403 ? 'blocked' : taskResponse.status === 404 ? 'missing' : 'failed', taskId: id,
+      code: typeof taskBody?.error === 'string' ? taskBody.error : taskResponse.status === 404 ? 'cloud-task-not-found' : 'cloud-status-unavailable', httpStatus: taskResponse.status };
+  }
+  const task = taskBody.task;
+  let usage = [];
+  let usageError;
+  const usageResponse = await requestTransport(origin, `/api/cloud-sandbox/tasks/${id}/usage`, {
+    headers: authenticatedHeaders(token),
+  });
+  try {
+    const usageBody = await responseBody(usageResponse);
+    if (usageResponse.ok) usage = publicUsage(usageBody?.usage);
+    else usageError = typeof usageBody?.error === 'string' ? usageBody.error : 'cloud-usage-unavailable';
+  } catch { usageError = 'cloud-usage-invalid-response'; }
+  await appendInvocation({ ...metadata, event: 'status' }, dependencies.home);
+  return { schemaVersion: CLOUD_STATUS_SCHEMA, status: 'observed', taskId: id,
+    taskStatus: task.status, task: publicTask(task), usage, ...(usageError ? { usageError } : {}) };
+}
+

package/local-cli.mjs

@@ -60,6 +60,17 @@ const operations = {
 
 export const LOCAL_OPERATIONS = Object.freeze(operations);
 
+function capabilitiesFor(group) {
+  if (group === undefined) return LOCAL_CAPABILITIES;
+  if (typeof group !== 'string' || !LOCAL_CAPABILITIES.groups.includes(group)) {
+    throw Object.assign(new Error(`Unknown local capability group: ${String(group)}`), { code: 'ENTROROVE_CAPABILITY_GROUP_UNKNOWN' });
+  }
+  const operations = LOCAL_CAPABILITIES.operations.filter(operation => LOCAL_CAPABILITIES.operationMetadata[operation]?.group === group);
+  return { ...LOCAL_CAPABILITIES, groups: [group], operations,
+    operationSchemas: Object.fromEntries(operations.map(operation => [operation, LOCAL_CAPABILITIES.operationSchemas[operation]])),
+    operationMetadata: Object.fromEntries(operations.map(operation => [operation, LOCAL_CAPABILITIES.operationMetadata[operation]])) };
+}
+
 async function checkedLocalInput(operation, input) {
   try { return validateLocalInput(operation, input); }
   catch (cause) {
@@ -73,7 +84,7 @@ export async function runLocal(args = [], dependencies) {
     const operation = args[0];
     if (operation === 'capabilities' || operation === 'help') {
       validateLocalInput(operation, process.stdin.isTTY ? {} : await stdinJson());
-      process.stdout.write(`${JSON.stringify(LOCAL_CAPABILITIES)}\n`); return;
+      process.stdout.write(`${JSON.stringify(capabilitiesFor(args[1]))}\n`); return;
     }
     const handler = operations[operation];
     if (!handler) throw new Error(`Usage: entrorove local <${['capabilities', ...Object.keys(operations)].join('|')}> [repositoryRoot]`);

package/local-contract-types.mjs

@@ -30,13 +30,19 @@ export const evidenceArray = array(evidence, 1);
 export const change = object({ gatePassPath: text, targetPath: relativePath, content: {}, expectedSha256: nullable(sha256), workerId: identifier, leaseId: identifier }, ['gatePassPath', 'targetPath', 'content']);
 export const decimal = { anyOf: [{ type: 'string', pattern: '^\\s*[+-]?(?:[0-9]+(?:\\.[0-9]*)?|\\.[0-9]+)\\s*$' }, { type: 'number' }] };
 export const formula = { $ref: '#/$defs/formula' };
+const formulaBranch = (schema, title, description) => ({ ...schema, title, description });
 function expression(operators, minItems, maxItems) {
-  return object({ op: enumeration(operators), args: { ...array(formula, minItems), ...(maxItems === undefined ? {} : { maxItems }) } }, ['op', 'args']);
+  const name = operators.join('|');
+  const arity = maxItems === undefined ? `${minItems} or more` : minItems === maxItems ? `exactly ${minItems}` : `${minItems} to ${maxItems}`;
+  return formulaBranch(object({ op: enumeration(operators), args: { ...array(formula, minItems), ...(maxItems === undefined ? {} : { maxItems }) } }, ['op', 'args']),
+    `${name} formula node`, `Operator ${name} requires ${arity} arguments.`);
 }
 export const formulaDefinitions = { formula: { oneOf: [
-  object({ ref: text }, ['ref']), object({ lit: decimal }, ['lit']),
+  formulaBranch(object({ ref: text }, ['ref']), 'Reference formula node', 'Reads one named input field.'),
+  formulaBranch(object({ lit: decimal }, ['lit']), 'Literal formula node', 'Contains one decimal literal.'),
   expression(['add', 'mul'], 1), expression(['sub', 'div', 'safeDivide', 'percentOf'], 2, 2),
-  expression(['round'], 1, 1), expression(['if'], 3, 3),
+  formulaBranch(expression(['round'], 1, 1), 'round formula node', 'Uses half-away-from-zero rounding at the declared two decimal places.'),
+  expression(['if'], 3, 3),
 ] } };
 export const decimalValues = { type: 'object', additionalProperties: decimal };
 export const formulaEntry = { type: 'object', properties: { key: text, expression: formula }, required: ['key', 'expression'] };

package/local-contracts.mjs

@@ -14,6 +14,7 @@ import { array, binding, change, confirmation, enumeration, evidence, evidenceAr
 const schemas = {};
 const base = { repositoryRoot: text, home: text };
 const flow = { ...base, flowId: identifier };
+const fixedRoundingPolicy = object({ decimalPlaces: { const: 2 }, mode: { const: 'half-away-from-zero' } }, ['decimalPlaces', 'mode']);
 const step = { ...flow, stepId: identifier };
 function add(names, properties, required = [], alternatives) {
   const schema = object(properties, required);
@@ -54,8 +55,8 @@ add('rollback', { ...step, snapshotId: identifier }, ['repositoryRoot', 'flowId'
 const check = { anyOf: [{ type: 'boolean' }, { type: 'object', properties: { status: text }, required: ['status'] }] };
 add('final-gate', { ...base, ...binding, audit: check, test: check, operations: check, evidence: array(evidence), preflight: record }, ['audit', 'test', 'operations', 'evidence']);
 schemas['final-gate'] = { oneOf: [schemas['final-gate'], FINAL_GATE16_INPUT_SCHEMA, FINAL_GATE16_READ_INPUT_SCHEMA] };
-add('formula-evaluate', { formula, values: decimalValues }, ['formula']);
-add('formula-graph', { formulas: array(formulaEntry), inputs: decimalValues }, ['formulas']);
+add('formula-evaluate', { formula, values: decimalValues, roundingPolicy: fixedRoundingPolicy }, ['formula']);
+add('formula-graph', { formulas: array(formulaEntry), inputs: decimalValues, roundingPolicy: fixedRoundingPolicy }, ['formulas']);
 add('formula-final-gate', { engine: record, flowId: identifier, stepId: identifier }, ['engine']);
 add('calculation-final-gate', { ...step, enginePath: relativePath }, ['repositoryRoot', 'enginePath']);
 add('run-approved-plan', { repositoryRoot: text, planPath: relativePath, approvalPath: text, signerConfigPath: nullable(text) }, ['repositoryRoot', 'planPath', 'approvalPath', 'signerConfigPath']);
@@ -114,9 +115,37 @@ Object.assign(schemas, ARCHGUARD_LOCAL_OPERATION_SCHEMAS, CALCTOOL_LOCAL_OPERATI
 export const LOCAL_OPERATION_SCHEMAS = Object.freeze(schemas);
 const ajv = new Ajv({ strict: true, strictRequired: false, allErrors: true });
 const validators = new Map(Object.entries(schemas).map(([operation, schema]) => [operation, ajv.compile(schema)]));
+const FORMULA_ARITY = { add: [1, Infinity], mul: [1, Infinity], sub: [2, 2], div: [2, 2], safeDivide: [2, 2], percentOf: [2, 2], round: [1, 1], if: [3, 3] };
+function formulaArityError(node, path) {
+  if (!node || typeof node !== 'object' || Array.isArray(node) || typeof node.op !== 'string') return undefined;
+  const bounds = FORMULA_ARITY[node.op];
+  if (!bounds) return undefined;
+  const count = Array.isArray(node.args) ? node.args.length : -1;
+  if (count < bounds[0] || count > bounds[1]) {
+    const expected = bounds[0] === bounds[1] ? `exactly ${bounds[0]}` : `at least ${bounds[0]}`;
+    return `${path}.args: operator "${node.op}" requires ${expected} arguments; received ${count < 0 ? 'non-array args' : count}`;
+  }
+  for (const [index, child] of node.args.entries()) {
+    const failure = formulaArityError(child, `${path}.args[${index}]`);
+    if (failure) return failure;
+  }
+  return undefined;
+}
+function formulaInputHint(operation, input) {
+  if (operation === 'formula-evaluate') return formulaArityError(input?.formula, 'formula');
+  if (operation === 'formula-graph' && Array.isArray(input?.formulas)) {
+    for (const [index, entry] of input.formulas.entries()) {
+      const failure = formulaArityError(entry?.expression, `formulas[${index}].expression`);
+      if (failure) return failure;
+    }
+  }
+  return undefined;
+}
 export function validateLocalInput(operation, input) {
   const validate = validators.get(operation);
   if (!validate) throw Object.assign(new Error(`Unsupported local operation: ${operation}`), { code: 'ENTROROVE_OPERATION_UNKNOWN' });
+  const hint = formulaInputHint(operation, input);
+  if (hint) throw Object.assign(new Error(`Invalid ${operation} input: ${hint}`), { code: 'ENTROROVE_INPUT_INVALID' });
   if (!validate(input)) {
     const details = validate.errors.map(error => `${error.instancePath || '/'} ${error.message}`).join('; ');
     throw Object.assign(new Error(`Invalid ${operation} input: ${details}`), { code: 'ENTROROVE_INPUT_INVALID' });

package/local-error.mjs

@@ -1,4 +1,14 @@
 export const LOCAL_ERROR_SCHEMA = 'entrorove.local-error/1.0';
+export const LOCAL_ERROR_CODE_CATALOG = Object.freeze({
+  ENTROROVE_INPUT_INVALID: Object.freeze({ disposition: 'terminal', stability: 'stable' }),
+  ENTROROVE_OPERATION_UNKNOWN: Object.freeze({ disposition: 'terminal', stability: 'stable' }),
+  ENTROROVE_LOCAL_FAILURE: Object.freeze({ disposition: 'terminal', stability: 'stable' }),
+  DIV_ZERO: Object.freeze({ disposition: 'terminal', stability: 'stable' }),
+  ENTROROVE_MUTATE_NOT_ACCEPTED: Object.freeze({ disposition: 'needs-human', stability: 'stable' }),
+  ENTROROVE_MUTATION_AUTHORITY_REQUIRED: Object.freeze({ disposition: 'needs-human', stability: 'stable' }),
+  ENTROROVE_BUDGET_LEASE_EXPIRED: Object.freeze({ disposition: 'retriable', stability: 'stable' }),
+  ENTROROVE_GIT_READER_UNSUPPORTED: Object.freeze({ disposition: 'terminal', stability: 'stable' }),
+});
 
 const BLOCKED_CODES = new Set([
   'ENTROROVE_MUTATE_NOT_ACCEPTED', 'ENTROROVE_MUTATION_AUTHORITY_REQUIRED',
@@ -16,8 +26,16 @@ export function localErrorStatus(error) {
     ? 'blocked' : 'failed';
 }
 
+export function localErrorDisposition(code) {
+  const catalogued = LOCAL_ERROR_CODE_CATALOG[code];
+  if (catalogued) return catalogued.disposition;
+  if (/_LEASE_EXPIRED$|_BUSY$|_RECONNECT/.test(code)) return 'retriable';
+  if (BLOCKED_CODES.has(code) || /(?:AUTHORITY_REQUIRED|NOT_ACCEPTED|REVOKED)$/.test(code)) return 'needs-human';
+  return 'terminal';
+}
+
 export function localErrorEnvelope(error, fallbackCode = 'ENTROROVE_LOCAL_FAILURE') {
   const code = typeof error?.code === 'string' && error.code ? error.code : fallbackCode;
   const message = typeof error?.message === 'string' && error.message ? error.message : 'Local operation failed';
-  return { schemaVersion: LOCAL_ERROR_SCHEMA, status: localErrorStatus({ ...error, code }), code, message };
+  return { schemaVersion: LOCAL_ERROR_SCHEMA, status: localErrorStatus({ ...error, code }), code, disposition: localErrorDisposition(code), message };
 }

package/local-execution.mjs

@@ -275,7 +275,29 @@ export async function finalGate(input) {
     guarantee: 'Original engine, frozen role plans and actual three-party checks are required' };
 }
 
-export const LOCAL_CAPABILITIES = Object.freeze({ schemaVersion: LOCAL_SCHEMA, operations: Object.freeze(Object.keys(LOCAL_OPERATION_SCHEMAS)), operationSchemas: LOCAL_OPERATION_SCHEMAS, stateDirectory: '~/.entrorove', forbidGitBranch: true, forbidWorktree: true, evidenceSchema: EVIDENCE_SCHEMA, budgets: READ_BUDGETS, validatorRunner: RUNNER_CAPABILITIES, workflowRunner: WORKFLOW_LOCAL_CAPABILITIES });
+const LOCAL_OPERATION_GROUPS = Object.freeze(['core', 'budget', 'scope', 'merge', 'chain', 'handoff', 'archguard', 'calctool', 'swarm', 'validator', 'formula', 'evidence']);
+const PASS_REQUIRED_OPERATIONS = new Set(['mutation-snapshot-attest', 'mutate-gate', 'gate-issue', 'gate-verify', 'guarded-write',
+  'merge-verified', 'rollback', 'archguard-contract-create', 'archguard-contract-update', 'archguard-checkpoint', 'archguard-scope-request',
+  'budget-handoff', 'budget-transition', 'spawn-bind', 'peer-complete', 'complete']);
+function operationGroup(operation) {
+  if (operation.startsWith('archguard-')) return 'archguard';
+  if (operation.startsWith('calctool-')) return 'calctool';
+  if (operation.includes('handoff')) return 'handoff';
+  if (operation.startsWith('budget-')) return 'budget';
+  if (operation.startsWith('chain-')) return 'chain';
+  if (operation.startsWith('formula-')) return 'formula';
+  if (operation.startsWith('merge-') || ['branch-create', 'branch-create-virtual', 'branch-list', 'branch-switch', 'diff-report', 'preflight', 'ledger-query'].includes(operation)) return 'merge';
+  if (operation.startsWith('peer-') || ['coordinate', 'spawn-bind', 'complete', 'lease-verify'].includes(operation)) return 'swarm';
+  if (operation.startsWith('evidence-')) return 'evidence';
+  if (operation.startsWith('probe') || operation === 'reassess' || operation.startsWith('snapshot') || operation.includes('scope')) return 'scope';
+  if (operation === 'final-gate' || operation.includes('verify') || operation.includes('validate')) return 'validator';
+  return 'core';
+}
+const LOCAL_OPERATION_METADATA = Object.freeze(Object.fromEntries(Object.keys(LOCAL_OPERATION_SCHEMAS).map(operation => [operation, Object.freeze({
+  group: operationGroup(operation), requiresPass: PASS_REQUIRED_OPERATIONS.has(operation),
+})])));
+export const LOCAL_CAPABILITIES = Object.freeze({ schemaVersion: LOCAL_SCHEMA, operations: Object.freeze(Object.keys(LOCAL_OPERATION_SCHEMAS)), operationSchemas: LOCAL_OPERATION_SCHEMAS,
+  operationMetadata: LOCAL_OPERATION_METADATA, groups: LOCAL_OPERATION_GROUPS, stateDirectory: '~/.entrorove', forbidGitBranch: true, forbidWorktree: true, evidenceSchema: EVIDENCE_SCHEMA, budgets: READ_BUDGETS, validatorRunner: RUNNER_CAPABILITIES, workflowRunner: WORKFLOW_LOCAL_CAPABILITIES });
 export function capabilities() { return LOCAL_CAPABILITIES; }
 export const guardedWriteFile = guardedWrite;
 export const verifyMutationPassFile = verifyMutationPass;

package/local-scope-config-imports.mjs

@@ -0,0 +1,192 @@
+import { createHash } from 'node:crypto';
+import path from 'node:path';
+import ts from 'typescript';
+const missing = (error) => ['ENOENT', 'ENOTDIR'].includes(error?.code ?? '');
+function literal(value, field) {
+    if (typeof value !== 'string' || !value || value !== value.trim() || value !== value.normalize('NFC')
+        || /[\\:\u0000-\u001f\u007f]/.test(value) || value.startsWith('/') || value.startsWith('~')) {
+        throw new Error(`Scope tsconfig ${field} requires a supported repository-relative literal path`);
+    }
+    return value;
+}
+function within(directory, value, allowRoot = false) {
+    const resolved = path.posix.normalize(path.posix.join(directory, literal(value, 'path'))).replace(/\/+$/, '');
+    if (resolved === '..' || resolved.startsWith('../') || resolved.startsWith('/')
+        || resolved.split('/').some(part => ['node_modules', '.git', '.entrorove', '.aimlock', '.archguard'].includes(part))) {
+        throw new Error('Scope tsconfig path escapes the authorized repository');
+    }
+    if (resolved === '.') {
+        if (!allowRoot)
+            throw new Error('Scope tsconfig mapping requires a literal candidate within the repository');
+        return '';
+    }
+    return resolved;
+}
+function pathsOption(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('Scope tsconfig paths requires an object of literal mappings');
+    const result = Object.create(null);
+    const entries = Object.entries(value);
+    if (entries.length > 512)
+        throw new Error('Scope tsconfig paths exceeds 512 mappings');
+    for (const [key, targets] of entries) {
+        if (!key || key !== key.trim() || key !== key.normalize('NFC') || /[\\:\u0000-\u001f\u007f]/.test(key)
+            || key.startsWith('/') || key.split('/').some(part => part === '.' || part === '..') || key.split('*').length > 2) {
+            throw new Error('Scope tsconfig paths supports only exact or single-wildcard mappings');
+        }
+        if (!Array.isArray(targets) || !targets.length || targets.length > 128 || targets.some(target => typeof target !== 'string')) {
+            throw new Error('Scope tsconfig paths targets must be a nonempty bounded string array');
+        }
+        result[key] = targets.map(target => {
+            literal(target, 'mapping');
+            if (target.split('*').length > 2 || (target.includes('*') && !key.includes('*'))) {
+                throw new Error('Scope tsconfig paths target has an unsupported wildcard mapping');
+            }
+            return target;
+        });
+    }
+    return result;
+}
+function parsedConfig(relative, source) {
+    const parsed = ts.parseConfigFileTextToJson(relative, source);
+    if (parsed.error)
+        throw new Error(`Scope tsconfig JSONC syntax is invalid (diagnostic ${parsed.error.code})`);
+    if (!parsed.config || typeof parsed.config !== 'object' || Array.isArray(parsed.config))
+        throw new Error('Scope tsconfig must contain a configuration object');
+    return parsed.config;
+}
+function pathMatch(paths, specifier) {
+    if (!paths)
+        return null;
+    if (Object.hasOwn(paths, specifier))
+        return { targets: paths[specifier], wildcard: '' };
+    let selected = null;
+    let prefixLength = -1;
+    for (const [key, targets] of Object.entries(paths)) {
+        const star = key.indexOf('*');
+        if (star < 0)
+            continue;
+        const prefix = key.slice(0, star);
+        const suffix = key.slice(star + 1);
+        if (prefix.length > prefixLength && specifier.startsWith(prefix) && specifier.endsWith(suffix)
+            && specifier.length >= prefix.length + suffix.length) {
+            selected = { targets, wildcard: specifier.slice(prefix.length, specifier.length - suffix.length) };
+            prefixLength = prefix.length;
+        }
+    }
+    return selected;
+}
+function importCandidates(resolution, specifier) {
+    if (typeof specifier !== 'string' || !specifier)
+        throw new Error('Scope tsconfig import specifier must be nonempty');
+    if (specifier.startsWith('node:') || specifier.startsWith('./') || specifier.startsWith('../'))
+        return [];
+    if (specifier !== specifier.trim() || /[\\:\u0000-\u001f\u007f*]/.test(specifier)
+        || specifier.startsWith('/') || specifier.split('/').some(part => part === '.' || part === '..')) {
+        throw new Error('Scope tsconfig import alias or candidate uses an unsupported path');
+    }
+    const match = pathMatch(resolution?.paths, specifier);
+    if (match) {
+        const base = resolution.baseUrl ?? resolution.pathsOrigin;
+        return [...new Set(match.targets.map(target => within(base, target.replace('*', match.wildcard))))];
+    }
+    if (specifier.startsWith('@/') || specifier.startsWith('#') || specifier.startsWith('~/')) {
+        throw new Error('Scope local import alias requires an actual tsconfig or package-import mapping');
+    }
+    return resolution?.baseUrl !== undefined ? [within(resolution.baseUrl, specifier)] : [];
+}
+export async function scopeTsconfigImports(read, fromFile, configPath) {
+    const canonical = within('', fromFile);
+    if (canonical !== fromFile)
+        throw new Error('Scope tsconfig source path must be canonical within the repository');
+    const observed = new Map();
+    const absent = new Set();
+    let bytes = 0;
+    const metadata = async (relative) => {
+        if (absent.has(relative))
+            return null;
+        if (observed.has(relative))
+            return Buffer.from(observed.get(relative).contentBase64, 'base64').toString('utf8');
+        let item;
+        try {
+            item = await read(relative);
+        }
+        catch (error) {
+            if (missing(error)) {
+                absent.add(relative);
+                return null;
+            }
+            ;
+            throw error;
+        }
+        const data = Buffer.from(item.contentBase64, 'base64');
+        if (item.path !== relative || data.toString('base64') !== item.contentBase64
+            || createHash('sha256').update(data).digest('hex') !== item.sha256 || !Buffer.from(data.toString('utf8')).equals(data)) {
+            throw new Error('Scope tsconfig metadata lost its actual path, UTF-8 content or hash');
+        }
+        bytes += data.length;
+        if (data.length > 1024 * 1024 || bytes > 16 * 1024 * 1024)
+            throw new Error('Scope tsconfig metadata exceeds its bounded read size');
+        observed.set(relative, item);
+        return data.toString('utf8');
+    };
+    const load = async (relative, ancestors, depth = 0) => {
+        if (depth >= 10)
+            throw new Error('Scope tsconfig extends exceeds the 10-configuration depth bound');
+        let source = await metadata(relative);
+        if (source === null && !relative.endsWith('.json')) {
+            relative += '.json';
+            source = await metadata(relative);
+        }
+        if (source === null)
+            throw new Error('Scope tsconfig extends references a missing actual configuration');
+        if (ancestors.has(relative))
+            throw new Error('Scope tsconfig extends contains a configuration cycle');
+        const config = parsedConfig(relative, source);
+        const directory = path.posix.dirname(relative) === '.' ? '' : path.posix.dirname(relative);
+        let inherited = { pathsOrigin: directory };
+        if (config.extends !== undefined) {
+            const extended = literal(config.extends, 'extends');
+            if (!extended.startsWith('./') && !extended.startsWith('../'))
+                throw new Error('Scope tsconfig npm extends is unsupported; use an actual repository-relative extends');
+            inherited = await load(within(directory, extended), new Set([...ancestors, relative]), depth + 1);
+        }
+        const options = config.compilerOptions === undefined ? {} : config.compilerOptions;
+        if (!options || typeof options !== 'object' || Array.isArray(options))
+            throw new Error('Scope tsconfig compilerOptions must be an object');
+        const own = options;
+        return { ...inherited,
+            ...(own.baseUrl === undefined ? {} : { baseUrl: within(directory, literal(own.baseUrl, 'baseUrl'), true) }),
+            ...(own.paths === undefined ? {} : { paths: pathsOption(own.paths), pathsOrigin: directory }) };
+    };
+    let directory = path.posix.dirname(canonical);
+    let resolution = null;
+    if (configPath !== undefined) {
+        if (within('', configPath) !== configPath || !/(?:^|\/)(?:ts|js)config(?:\.[^/]+)?\.json$/.test(configPath))
+            throw new Error('Scope import context requires an actual repository-relative tsconfig or jsconfig');
+        resolution = await load(configPath, new Set());
+    }
+    while (configPath === undefined) {
+        const prefix = directory === '.' ? '' : `${directory}/`;
+        const relative = await metadata(`${prefix}tsconfig.json`) !== null ? `${prefix}tsconfig.json`
+            : await metadata(`${prefix}jsconfig.json`) !== null ? `${prefix}jsconfig.json` : null;
+        if (relative !== null) {
+            resolution = await load(relative, new Set());
+            break;
+        }
+        if (directory === '.')
+            break;
+        directory = path.posix.dirname(directory);
+    }
+    if (resolution?.paths)
+        for (const targets of Object.values(resolution.paths))
+            for (const target of targets) {
+                within(resolution.baseUrl ?? resolution.pathsOrigin, target.replace('*', '__scope_wildcard__'));
+            }
+    return { candidates: specifier => importCandidates(resolution, specifier), mapped: specifier => {
+            if (typeof specifier !== 'string' || !specifier)
+                throw new Error('Scope tsconfig mapping lookup requires a nonempty specifier');
+            return pathMatch(resolution?.paths, specifier) !== null;
+        }, observations: [...observed.keys()].sort()
+            .map(relative => ({ path: relative, sha256: observed.get(relative).sha256 })) };
+}

package/local-scope-repository.mjs

@@ -11,6 +11,7 @@ import { workspaceImport, workspaceIndex } from './local-scope-workspaces.mjs';
 import { assertBudgetRunnerAllowed } from './local-budget-reads.mjs';
 import { observeBudgetScopeGit, scopeGitBudgetEnforced } from './local-scope-git.mjs';
 import { scopeGitMetadata } from './local-scope-git-reads.mjs';
+import { scopeTsconfigImports } from './local-scope-config-imports.mjs';
 
 const execute = promisify(execFile);
 async function git(root, args, allowed = [], input = { repositoryRoot: root }) {
@@ -179,48 +180,83 @@ function importSpecifiers(content, filename) {
   }
 }
 const sourceExtension = /\.(?:[cm]?[jt]sx?|vue)$/i;
-async function resolveImport(root, from, specifier, workspace, input) {
+function declarationModules(content, from) {
+  if (!/\.d\.[cm]?ts$/i.test(from)) return new Set();
+  const parsed = ts.createSourceFile(from, content.toString('utf8'), ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+  return new Set(parsed.statements.filter(node => ts.isModuleDeclaration(node) && ts.isStringLiteral(node.name)
+    && node.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.DeclareKeyword)).map(node => node.name.text));
+}
+async function resolveImport(root, from, specifier, workspace, input, aliases, configPath, declarations) {
   if (/^(?:https?:|file:|data:)/i.test(specifier)) scopeFail('ENTROROVE_IMPORT_UNSUPPORTED', 'remote source imports cannot be inspected as local facts');
+  if (declarations.has(specifier)) return null;
+  const label = /^[A-Za-z0-9@._/~+-]{1,256}$/.test(specifier) ? specifier : '[unsupported specifier]';
+  let candidates;
+  try { candidates = aliases.candidates(specifier); }
+  catch (error) { scopeFail('ENTROROVE_IMPORT_UNRESOLVED', `${from}: ${error.message}; specify its actual build config with importContexts`); }
+  for (const candidate of candidates) {
+    const resolved = await resolveLocalImport(root, candidate, false);
+    if (resolved) return resolved;
+  }
+  if (aliases.mapped(specifier)) scopeFail('ENTROROVE_IMPORT_UNRESOLVED', `${from}: ${label} has no actual resolvable source file in its build config`);
   const localPackage = !specifier.startsWith('.') ? workspaceImport(workspace, specifier) : null;
   if (!specifier.startsWith('.') && !localPackage) {
     if (builtinModules.includes(specifier) || (specifier.startsWith('node:') && builtinModules.includes(specifier.slice(5)))) return null;
-    const boundary = await packageBoundary(root, from, input);
+    const boundary = await packageBoundary(root, configPath ?? from, input);
     if (boundary.manifestPath) {
       const manifest = JSON.parse((await scopeRead(root, boundary.manifestPath, input)).content.toString('utf8'));
       const name = specifier.startsWith('@') ? specifier.split('/').slice(0, 2).join('/') : specifier.split('/')[0];
       if (['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies'].some(field => Object.hasOwn(manifest[field] ?? {}, name))) return null;
     }
-    scopeFail('ENTROROVE_IMPORT_UNRESOLVED', 'bare imports require a builtin, declared dependency, or actual workspace export; unresolved aliases cannot be assumed external');
+    scopeFail('ENTROROVE_IMPORT_UNRESOLVED', `${from}: ${label} requires a builtin, declared dependency, or actual workspace export`);
   }
   const relative = localPackage ?? path.posix.normalize(path.posix.join(path.posix.dirname(from), specifier));
+  return resolveLocalImport(root, relative);
+}
+async function resolveLocalImport(root, relative, required = true) {
   if (relative.startsWith('../') || relative === '..') scopeFail('ENTROROVE_PATH_UNSAFE', 'local import escapes the repository');
   const replacements = /\.js$/.test(relative) ? [relative.replace(/\.js$/, '.ts'), relative.replace(/\.js$/, '.tsx')] : [];
-  for (const candidate of [relative, ...replacements, ...['.js', '.mjs', '.cjs', '.ts', '.tsx', '.jsx', '/index.js', '/index.ts'].map(ext => relative + ext)]) {
+  for (const candidate of [relative, ...replacements, ...['.js', '.mjs', '.cjs', '.ts', '.tsx', '.jsx', '.vue', '.json', '.d.ts', '.d.mts', '.d.cts', '/index.js', '/index.ts', '/index.d.ts'].map(ext => relative + ext)]) {
     const item = await scopeTarget(root, candidate, true);
     if (item.exists && item.stat.isFile()) return candidate;
   }
-  scopeFail('ENTROROVE_IMPORT_UNRESOLVED', 'a local import has no resolvable source file');
+  if (required) scopeFail('ENTROROVE_IMPORT_UNRESOLVED', 'a local import has no resolvable source file');
+  return null;
 }
 export async function importGraph(root, originals, input = { repositoryRoot: root }) {
   const pending = originals.filter(file => file.exists !== false).map(file => file.path); const visited = new Map(); const edges = []; let dynamic = false;
+  const dynamicSources = [];
   const workspace = await workspaceIndex(root, input);
+  const metadata = new Map(workspace.metadata.map(item => [item.path, item]));
   while (pending.length) {
     const relative = pending.shift(); if (visited.has(relative)) continue;
     if (visited.size >= 1000) scopeFail('ENTROROVE_SCOPE_LIMIT', 'import graph exceeds the 1000-file inspection bound');
     const read = await scopeRead(root, relative, input); const boundary = await packageBoundary(root, relative, input);
     visited.set(relative, { path: relative, sha256: read.sha256, module: boundary.path, boundary });
     if (!sourceExtension.test(relative)) continue;
+    const contexts = (input.importContexts ?? []).filter(context => relative === context.sourcePrefix || relative.startsWith(`${context.sourcePrefix}/`))
+      .sort((a, b) => b.sourcePrefix.length - a.sourcePrefix.length);
+    const configPath = contexts[0]?.configPath;
+    const aliases = await scopeTsconfigImports(async target => {
+      const item = await scopeRead(root, target, input);
+      return { path: target, sha256: item.sha256, contentBase64: item.content.toString('base64') };
+    }, relative, configPath);
+    for (const observed of aliases.observations) metadata.set(observed.path, observed);
+    const declarations = declarationModules(read.content, relative);
     const imports = importSpecifiers(read.content, relative); dynamic ||= imports.dynamic;
+    if (imports.dynamic) dynamicSources.push({ path: relative, sha256: read.sha256 });
     for (const specifier of imports.specifiers.sort()) {
-      const target = await resolveImport(root, relative, specifier, workspace, input);
-      edges.push({ from: relative, to: target, external: target === null, specifier });
+      const target = await resolveImport(root, relative, specifier, workspace, input, aliases, configPath, declarations);
+      edges.push({ from: relative, to: target, external: target === null, specifier,
+        ...(declarations.has(specifier) ? { declarationOnly: true, declarationPath: relative } : {}) });
       if (target !== null && !visited.has(target)) pending.push(target);
     }
   }
   const nodes = [...visited.values()].sort((a, b) => a.path.localeCompare(b.path));
   await stableScope(root, nodes, input);
-  await stableScope(root, workspace.metadata, input);
-  return { nodes, edges: edges.sort((a, b) => `${a.from}:${a.specifier}`.localeCompare(`${b.from}:${b.specifier}`)), dynamic, complete: !dynamic, workspaceMetadata: workspace.metadata };
+  const workspaceMetadata = [...metadata.values()].sort((a, b) => a.path.localeCompare(b.path));
+  await stableScope(root, workspaceMetadata, input);
+  return { nodes, edges: edges.sort((a, b) => `${a.from}:${a.specifier}`.localeCompare(`${b.from}:${b.specifier}`)),
+    dynamic, complete: !dynamic, dynamicSources: dynamicSources.sort((a, b) => a.path.localeCompare(b.path)), workspaceMetadata };
 }
 export async function collectScopeFacts(root, requested, baselineRef, knownFiles = [], input = { repositoryRoot: root }) {
   const selected = await scopeFiles(root, requested, knownFiles); const files = [];

package/manifest.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": "entrorove.skill-manifest/1.0",
   "name": "entrorove",
-  "version": "0.1.31",
+  "version": "0.1.33",
   "endpoint": "https://entrorove.com",
   "requestSchemaVersion": "entrorove.skill.request/2.0",
   "supportedRequestSchemaVersions": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@entrorove/skill",
-  "version": "0.1.31",
+  "version": "0.1.33",
   "type": "module",
   "bin": {
     "entrorove": "cli.mjs"
@@ -76,6 +76,7 @@
     "local-task-handoff-write-archive.mjs",
     "local-task-handoff-write-receipts.mjs",
     "remote-client.mjs",
+    "scope-runner-client.mjs",
     "cloud-task-client.mjs",
     "remote-transport.mjs",
     "local-credential.mjs",
@@ -122,6 +123,7 @@
     "local-scope-files.mjs",
     "local-scope-repository.mjs",
     "local-scope-signature.mjs",
+    "local-scope-config-imports.mjs",
     "local-scope-snapshot.mjs",
     "local-scope-state.mjs",
     "local-scope-workspaces.mjs",

package/release-state.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": "entrorove.release-state/1.0",
-  "version": "0.1.31",
-  "digest": "005df83b58c713b893d715a7480c08a91896301f6295746525f49abd2d746044",
+  "version": "0.1.33",
+  "digest": "79b9167ef252402e374202c08093e75e98fe3bf41227a53f34a44fa757834fe2",
   "files": {
     "local-final-gate16.mjs": "b30caab08441449ad556a6e9a3cefbf91190f0b3f7370f46d2a21156375aa8e3",
     "local-final-gate16-checks.mjs": "1dd30e9666d458d8b12ca6e4975f6f0ac8450c3ea9cbecc7401ae037f66b589a",
@@ -44,23 +44,23 @@
     "local-autocoord17-waits.mjs": "2b0a713987822548a94e1ed3a9a891532db45383797dfc5d5bc8d1e35593cf25",
     "local-validator-isolation17.mjs": "48e94604e28b8fddd567dfb35ff60b73fd094a5803bd49f076388b7f310f92aa",
     "local-calctool-composition17.mjs": "ac89fcb41ab0d0d9b47c1b5696945281b0894eb064820775e36a011c76314e6a",
-    "cli.mjs": "6b2f31ee3204c8584ac4733a9b2d1c6ca72e2ea205e84f8a314a68f31917f629",
+    "cli.mjs": "d06e372e7f54f726b700b0d909669616c5f35aa7eaa6c67c008d0670ac18678a",
     "review-client.mjs": "3491eef68ed533174b31db3c53febb6519b8f088f71a9964644714a9a4c03c77",
     "version.mjs": "1f392147d72c40af4b03b307ea607075fb815af5174fa07e254b95fe12dbf3e7",
-    "SKILL.md": "fa3fa41f1551e54512de0cae7940e2d7ad670f81a46c2e642cdc2323b171224f",
-    "CAPABILITY-MAP.md": "128ecc8d90b2c17846ce6f0c650eada9e7fa7240f5d3c03b31e3ee01135557b8",
+    "SKILL.md": "726140d61da8561a6a87ff818931964994ad5356c56c45afeb6b5133609697ab",
+    "CAPABILITY-MAP.md": "4b8479928481289b82540ff2624ebb16d1f0a5b6697b6eec52d2d459f86a0001",
     "AGREEMENT.md": "f93a68e92c457200dd024610e65f74e478b8f60860f951da818b70561f1b9bf8",
-    "package.json": "77e29f7740cc2a2284490a992a9945fbb4a3ad3ac044f4ff9a59b1aa83e44ae0",
+    "package.json": "2afd7c74c464da6f8fa7dfa58d465104e77c1d332ec2b4adb17a8df518b0d3ba",
     "manifest.json": "ab06e307795bc9da5add926752b6c4dbdaf18625090261a035aa356a679c504f",
-    "release.mjs": "1e6155d10b5e6384414233847815742e13f0945101c5f53253ad9ca827766beb",
-    "local-cli.mjs": "ecc85bc5f36a5663fef004e59525374dc7883d3889f5a0cfe219ae5e84b2d3ea",
+    "release.mjs": "e33a80cb7463f4db532af18d26880b198de637d376ce1952d751668bbd8df44d",
+    "local-cli.mjs": "a79037d7383a29822b465e6db1c862a43d47cc344f05b6651c849633c49d19f7",
     "local-state-lock.mjs": "1dbf64264642a0851faf043e07ee9f66d2ad0508e9f799b0626246e42fae893e",
-    "local-execution.mjs": "97dfad5e889e679e9cc34434005342526502795abba21078fa40673788073153",
+    "local-execution.mjs": "cdada6df6dc8831cebb58a629b56c4b3f8e1bf9aae4e3fdc121521ba20839383",
     "local-integrity.mjs": "4f325376e536999c3b00245f66aac9ef1ae762c33012b363c231622008f72805",
     "local-evidence-verification.mjs": "9b7dea31777505272f63616fd62af7603338f703bb1285fc565d6451715c7ce0",
     "local-formula.mjs": "706d5ec0cb2caf95a547531a81ca746fe246d4c53d902e03595a3b360e8c85af",
     "local-ledger.mjs": "2009fb68aadcd7292b72f1d0d99f378d03644be1c5b4b4150d9f6a0b3f7c15ce",
-    "local-error.mjs": "66484e2e27c9870a17dc0f1cf64d108ea384ad9fb41b7adc3aacb243ae65fe2e",
+    "local-error.mjs": "9dc42763ca7013cde607543308e029796d68f3b020a5a3b4ad9e68815e38d0f5",
     "blueprint-criterion-wire.mjs": "fb6b7dcce0b97a699e3e8968372767a3fddd83fedc750998573f789177243072",
     "blueprint-criterion-runner.mjs": "761c0e670b4b20c6bed53e5ca5d0178759505c3977ea2ed1b7223383c534bc4c",
     "local-chain-bindings.mjs": "b8eff999ccd17b53c614a3c9f5376da78fcaa8632bb3e07bc1adcceda2e75f6c",
@@ -89,7 +89,7 @@
     "local-scope-candidate.mjs": "8f0bd9606e70d4a0ebacdd3cd600ec3afed85e2bb3e1760aa1144cf55d4e028a",
     "local-scope-context.mjs": "79753abfc6c76089d17f003a1be537dfaea10d6731c542f7fc53f2a9996ed164",
     "local-scope-files.mjs": "0671ac4baef610a55ea6c1db6ebca7a4b6cfda45edb8aeaa828019e2a26f5a76",
-    "local-scope-repository.mjs": "f3fa673fdb4b37bb085ce0caab6a24be2b9f056e12d59bd81aac798d85dd507c",
+    "local-scope-repository.mjs": "af7fe24408509dcebe39bdfc6fcef6adcf66f6ad09473149f920d5e921a48d1a",
     "local-scope-git.mjs": "53bbbb6c4795db711b5bc164591a6ad79a561427da046d6bbe997dae6eb82829",
     "local-scope-git-reads.mjs": "d18d4441664aa59ad8360ee16a69fc0282e7530705d5ae7950944a8158448bb4",
     "local-scope-git-comparison.mjs": "d86e559843087ae851795c9fb16b844dc46cc461fb5da37dbca0f6ba0d06450b",
@@ -113,12 +113,14 @@
     "runtime/git-native-linux-v1.mjs": "cf5cb91426a105e62c0f07a8a230dec592dba46f85a3f708b4c4e8cfcd1126c6",
     "runtime/git-native-darwin-v1.mjs": "f88aab72dc86f94eb1115784872957cb8ed0f74205ae70e1ecd1939e7790e310",
     "local-scope-signature.mjs": "bd05e8cf9e23f9511a16844974362297b9e9d11930ff7b8ad2a490e8d7660fe9",
+    "local-scope-config-imports.mjs": "16053142410dd647f13360f29fb3680c3e3a3ebc38019e43af6db05896d92a33",
     "local-scope-snapshot.mjs": "c0f851470b98863a1d187825ed61ee6072d1c057b178fdc85ae29af02a3b250f",
     "local-scope-state.mjs": "8b600a91fc0068d7a8c0bb752ddba7ed30ada93daafb118d6cba2368fd94cb27",
     "local-scope-workspaces.mjs": "a44c34537e5ed2dcaf193a985e5bc05957989fbb160a650f9e37ba7d66eb2de8",
     "local-task-routing.mjs": "e26d6f1ba134ffe1da2a49b4fb6bb6dfa5617671f774a08e719d04f202cf5eca",
-    "remote-client.mjs": "ce16258faffb09c9db19609d47a0af6f63fcbc256feb35ba7a14bbb89e69cc6e",
-    "cloud-task-client.mjs": "b7dc4be6c4d2a60404538e3d875cf95533e1b7be3f43ac7f5d49118042ce1d45",
+    "remote-client.mjs": "6df222e3e55a893fda2aa7a15feb545db5ff9d74e33025a1b0e3f03b849f5d14",
+    "cloud-task-client.mjs": "d519e2c020e19a67e8c6e32d2da39bc3fa45538b773e7baf02605505d065daaf",
+    "scope-runner-client.mjs": "940c841e2c56e92793e5bf65e713bf4087151f721d0ecb659e0a75d6fdefeab9",
     "remote-transport.mjs": "5e5a8c0b490371f7f5a052cffbeee6202d4cf713dff1c43b6d910fe944f8429c",
     "local-credential.mjs": "2a302a7f67b5ea8dc73453fc96ab33db349b59ca11fa9456e48ca1d9669d877c",
     "local-invocations.mjs": "f6ac4c41c1a5ec34de358c4cca210ca8e403b3a913150a43bb55ec9be55d9998",
@@ -139,8 +141,8 @@
     "workflow-local-request.mjs": "4e24c543ce386292a87dc9cd41f90d23375f12079cacffc515c8cd01fd571780",
     "task-message-entry.mjs": "31d10056cb905237cd5649e8eb067009ff1612ec5dc1061e0373209fbc0b646a",
     "task-message-cli.mjs": "3ca65e96c28129b3bd5cac962d106e0859a1f17df1f6a66ee543c6efc22f918d",
-    "local-contracts.mjs": "43715cd73460ccea734501a3dd5667184da0f6a5b0189e038319a439ba52fc76",
-    "local-contract-types.mjs": "5d244237fc69052b2fa83098022761bae929e8b75a0683883b620711bc132050",
+    "local-contracts.mjs": "e6c6b9b8b8b89e991c5689d935e26ccd92d398405ebced298817d673095bca1e",
+    "local-contract-types.mjs": "85e71fa4dd67e351a4b67573c740bcdb1661cede53f097189f11837771e75e91",
     "local-archguard-ast.mjs": "cefd835312a623e83bf48e4d8e1f76ac6a8adc56c35843705c16967d16bec4e6",
     "local-archguard-checkpoint.mjs": "37896902520cc995720c96288e4a5ed3585952b55c9c35be281f91fa754c71ec",
     "local-archguard-components.mjs": "a8fb3d0fd787f9160905013fd333cc0b9e8cf624cce797461f36f4ab31d170ad",

package/release.mjs

@@ -86,10 +86,12 @@ const sourceFiles = [
   'runtime/git-native-linux-v1.mjs',
   'runtime/git-native-darwin-v1.mjs',
   'local-scope-signature.mjs',
+  'local-scope-config-imports.mjs',
   'local-scope-snapshot.mjs',
   'local-scope-state.mjs',
   'local-scope-workspaces.mjs',
   'local-task-routing.mjs', 'remote-client.mjs', 'cloud-task-client.mjs',
+  'scope-runner-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',
@@ -257,7 +259,15 @@ function releaseNote(changed) {
   if (suppliedZh && suppliedEn) return {
     zh: suppliedZh.replaceAll(/\s+/g, ' '), en: suppliedEn.replaceAll(/\s+/g, ' '),
   }
-  const labels = withFinalGate16ReleaseLabels({ ...calctoolReleaseLabels, ...mutationReleaseLabels, ...swarmReleaseLabels, ...coordination17ReleaseLabels, ...nativeReadReleaseLabels, ...feedbackReleaseLabels, ...invocationReleaseLabels, ...chainReleaseLabels,
+  if (changed.includes('scope-runner-client.mjs')) return {
+    zh: '补齐账号与任务隔离的本地签名器和真实快照接入，解析实际别名及类型声明；动态依赖仅进入受限规划，保留独立写入核验。',
+    en: 'Connected account-bound scope signers and real snapshots, resolved actual aliases and declarations, and retained restricted planning for unresolved dynamic imports with separate mutation verification.',
+  }
+  const distinct = distinctReleaseLabels(changed, releaseLabels())
+  return { zh: `更新了${distinct.map(label => label.zh).join('、')}。`, en: `Updated ${distinct.map(label => label.en).join(', ')}.` }
+}
+function releaseLabels() {
+  return withFinalGate16ReleaseLabels({ ...calctoolReleaseLabels, ...mutationReleaseLabels, ...swarmReleaseLabels, ...coordination17ReleaseLabels, ...nativeReadReleaseLabels, ...feedbackReleaseLabels, ...invocationReleaseLabels, ...chainReleaseLabels,
     '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' },
@@ -345,11 +355,6 @@ function releaseNote(changed) {
     'task-message-cli.mjs': { zh: '任务消息命令与适配器', en: 'task message command and adapter' },
     'cloud-task-client.mjs': { zh: '云端沙箱任务路由与逐任务选择', en: 'cloud sandbox task routing and per-task choice' },
   })
-  const distinct = distinctReleaseLabels(changed, labels)
-  return {
-    zh: `更新了${distinct.map(label => label.zh).join('、')}。`,
-    en: `Updated ${distinct.map(label => label.en).join(', ')}.`,
-  }
 }
 
 async function writeAll(changes) {

package/releases.json

@@ -1,4 +1,16 @@
 [
+  {
+    "version": "0.1.33",
+    "date": "2026-10-12",
+    "zh": "补齐账号与任务隔离的本地签名器和真实快照接入，解析实际别名及类型声明；动态依赖仅进入受限规划，保留独立写入核验。",
+    "en": "Connected account-bound scope signers and real snapshots, resolved actual aliases and declarations, and retained restricted planning for unresolved dynamic imports with separate mutation verification."
+  },
+  {
+    "version": "0.1.32",
+    "date": "2026-10-11",
+    "zh": "增加云端沙箱状态与用量只读查询，并支持按任务直接读取真实状态。",
+    "en": "Added read-only cloud sandbox status and direct reads of authoritative task state and usage."
+  },
   {
     "version": "0.1.31",
     "date": "2026-10-11",

package/remote-client.mjs

@@ -33,6 +33,7 @@ export function buildInvocation(operation, input) {
   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',
+    'scope-runner-prepare', 'scope-runner-register', 'scope-runner-challenge', 'scope-runner-attest',
     '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);
@@ -62,8 +63,19 @@ export async function invokeRemote(data, dependencies) {
     process.exitCode = 2;
     return;
   }
-  const call = { ...buildInvocation(data.operation, data.input), url: `${trustedOrigin(apiOrigin())}/api/skill/invoke` };
   const token = await readCredential(home);
+  const { response, result } = await invokeDiscovered(data, token, { home, apiOrigin });
+  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;
+}
+
+export async function invokeRemoteResult(data, dependencies) {
+  const token = await machineCredential(dependencies);
+  return invokeDiscovered(data, token, dependencies);
+}
+async function invokeDiscovered(data, token, { home, apiOrigin }) {
+  const call = { ...buildInvocation(data.operation, data.input), url: `${trustedOrigin(apiOrigin())}/api/skill/invoke` };
   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}`);
@@ -74,10 +86,7 @@ export async function invokeRemote(data, dependencies) {
     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;
+  return postInvocation(call, token, home);
 }
 
 async function postInvocation(call, token, home) {

package/scope-runner-client.mjs

@@ -0,0 +1,125 @@
+import { createPrivateKey, createPublicKey, generateKeyPairSync, randomUUID, sign } from 'node:crypto';
+import { constants, promises as fs } from 'node:fs';
+import path from 'node:path';
+import { canonical, sha256 } from './local-integrity.mjs';
+import { scopeFail, scopePath, scopeRoot, scopeTarget } from './local-scope-files.mjs';
+import { withStateLock } from './local-state-lock.mjs';
+import { snapshotPlan, snapshotVerify } from './local-execution.mjs';
+import { probe } from './local-probe.mjs';
+import { invokeRemoteResult } from './remote-client.mjs';
+
+async function privateDirectory(directory) {
+  await fs.mkdir(directory, { recursive: true, mode: 0o700 });
+  const stat = await fs.lstat(directory);
+  if (!stat.isDirectory() || stat.isSymbolicLink() || process.getuid && stat.uid !== process.getuid()) {
+    scopeFail('ENTROROVE_SCOPE_STATE', 'Scope signer storage must belong to the current OS account');
+  }
+  if (process.platform !== 'win32') await fs.chmod(directory, 0o700);
+}
+async function readPrivate(file) {
+  const stat = await fs.lstat(file);
+  if (!stat.isFile() || stat.isSymbolicLink() || process.getuid && stat.uid !== process.getuid()
+    || process.platform !== 'win32' && (stat.mode & 0o077)) scopeFail('ENTROROVE_SCOPE_STATE', 'Scope signer files must be private regular files');
+  const handle = await fs.open(file, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+  try { return await handle.readFile('utf8'); } finally { await handle.close(); }
+}
+async function signer(directory, identity) {
+  const controls = path.join(directory, 'identity'), file = path.join(controls, 'binding.json');
+  let binding;
+  try { binding = JSON.parse(await readPrivate(file)); }
+  catch (error) { if (error.code !== 'ENOENT') throw error; }
+  if (!binding) {
+    const keys = generateKeyPairSync('ed25519'), publicDer = keys.publicKey.export({ type: 'spki', format: 'der' });
+    binding = { schemaVersion: 'entrorove.local-scope-binding/1.0', ...identity, runnerId: `local-scope-${randomUUID()}`,
+      repositoryId: `local-repository-${sha256(identity.repositoryRoot).slice(0, 32)}`, publicKey: publicDer.toString('base64'), keyId: sha256(publicDer) };
+    const stage = path.join(directory, `.signer-${randomUUID()}`); await privateDirectory(stage);
+    try {
+      await fs.writeFile(path.join(stage, 'private.pem'), keys.privateKey.export({ type: 'pkcs8', format: 'pem' }), { flag: 'wx', mode: 0o600 });
+      await fs.writeFile(path.join(stage, 'signer.json'), `${JSON.stringify({ schemaVersion: 'entrorove.scope-signer/1.0',
+        privateKeyPath: path.join(controls, 'private.pem'), keyId: binding.keyId, receiptTtlMs: 60_000 })}\n`, { flag: 'wx', mode: 0o600 });
+      await fs.writeFile(path.join(stage, 'binding.json'), `${JSON.stringify(binding)}\n`, { flag: 'wx', mode: 0o600 });
+      await fs.rename(stage, controls);
+    } finally { await fs.rm(stage, { recursive: true, force: true }); }
+  }
+  if (Object.keys(identity).some(field => canonical(binding[field]) !== canonical(identity[field]))) {
+    scopeFail('ENTROROVE_SCOPE_REPLACEMENT', 'The original local task signer, repository and path set cannot be replaced');
+  }
+  await privateDirectory(controls);
+  const key = createPrivateKey(await readPrivate(path.join(controls, 'private.pem')));
+  if (key.asymmetricKeyType !== 'ed25519' || sha256(createPublicKey(key).export({ type: 'spki', format: 'der' })) !== binding.keyId) {
+    scopeFail('ENTROROVE_SCOPE_STATE', 'Original scope signer key identity changed');
+  }
+  return { binding, key, signerConfigPath: path.join(controls, 'signer.json') };
+}
+async function remote(operation, input, dependencies) {
+  const { response, result } = await invokeRemoteResult({ operation, input }, dependencies);
+  if (!response.ok || result.output.status !== 'succeeded') {
+    throw Object.assign(new Error(result.output.message ?? `Scope connection blocked at ${operation}`),
+      { code: result.output.code ?? 'ENTROROVE_SCOPE_BLOCKED', output: result.output });
+  }
+  return result.output;
+}
+async function connect(identity, directory, dependencies) {
+  const { binding, key, signerConfigPath } = await signer(directory, identity);
+  const prepared = await remote('scope-runner-prepare', { flowId: identity.flowId, attemptId: randomUUID(), runnerId: binding.runnerId,
+    repositoryId: binding.repositoryId, publicKey: binding.publicKey, targetPaths: identity.targetPaths }, dependencies);
+  const enrollment = prepared.enrollment;
+  if (enrollment.flowId !== identity.flowId || enrollment.runnerId !== binding.runnerId || enrollment.keyId !== binding.keyId
+    || canonical(enrollment.targetPaths) !== canonical(identity.targetPaths)) scopeFail('ENTROROVE_SCOPE_BINDING', 'Cloud enrollment differs from the original local task signer');
+  await remote('scope-runner-register', { flowId: identity.flowId, enrollmentId: enrollment.enrollmentId,
+    signature: sign(null, Buffer.from(canonical(enrollment)), key).toString('base64url') }, dependencies);
+  const issued = await remote('scope-runner-challenge', { flowId: identity.flowId, receiverId: binding.runnerId, attemptId: randomUUID() }, dependencies);
+  const challenge = issued.challenge;
+  if (challenge.flowId !== identity.flowId || challenge.ownerId !== enrollment.ownerId || challenge.runnerId !== binding.runnerId
+    || challenge.repositoryId !== binding.repositoryId || challenge.taskDigest !== enrollment.taskDigest
+    || challenge.chainDigest !== enrollment.chainDigest || canonical(challenge.targetPaths) !== canonical(identity.targetPaths)) {
+    scopeFail('ENTROROVE_SCOPE_BINDING', 'Cloud scope challenge differs from the original account and accepted task');
+  }
+  const input = { repositoryRoot: identity.repositoryRoot, home: dependencies.home, flowId: identity.flowId,
+    stepId: challenge.stepId, paths: identity.targetPaths, snapshotId: `snapshot-${randomUUID()}`, importContexts: identity.importContexts };
+  const planned = await snapshotPlan(input), verified = await snapshotVerify(input);
+  if (verified.verified !== true || verified.receipt.snapshotDigest !== planned.snapshotDigest) scopeFail('ENTROROVE_SCOPE_SNAPSHOT', 'Actual copied snapshot did not verify');
+  const observed = await probe({ ...input, ownerId: challenge.ownerId, task: challenge.task, taskDigest: challenge.taskDigest,
+    chainDigest: challenge.chainDigest, repositoryId: challenge.repositoryId, challenge: challenge.challenge, signerConfigPath });
+  const accepted = await remote('scope-runner-attest', { flowId: identity.flowId, attestation: observed.attestation }, dependencies);
+  return { schemaVersion: 'entrorove.scope-connection/1.0', status: 'succeeded', flowId: identity.flowId,
+    runnerId: binding.runnerId, scopeEvidence: accepted.scopeEvidence, grantsExecutionAuthority: false,
+    nextOperation: 'workflow-gate' };
+}
+export async function connectScopeRunner(repositoryRoot, input, dependencies) {
+  if (!input || Object.keys(input).some(field => !['flowId', 'paths', 'importContexts'].includes(field))
+    || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(input.flowId ?? '') || !Array.isArray(input.paths) || !input.paths.length) {
+    scopeFail('ENTROROVE_SCOPE_INPUT', 'Expected {flowId,paths} for the original task and concrete existing source files');
+  }
+  const root = await scopeRoot(repositoryRoot), targetPaths = [...new Set(input.paths.map(scopePath))].sort();
+  if (targetPaths.length !== input.paths.length) scopeFail('ENTROROVE_SCOPE_INPUT', 'Scope paths must be unique');
+  for (const relative of targetPaths) {
+    const target = await scopeTarget(root, relative);
+    if (!target.stat.isFile()) scopeFail('ENTROROVE_SCOPE_INPUT', 'Scope connection requires concrete existing source files');
+  }
+  const importContexts = input.importContexts ?? [];
+  if (!Array.isArray(importContexts) || importContexts.length > 100 || new Set(importContexts.map(context => context?.sourcePrefix)).size !== importContexts.length) {
+    scopeFail('ENTROROVE_SCOPE_INPUT', 'Import contexts require unique source prefixes and at most 100 actual build configurations');
+  }
+  for (const context of importContexts) {
+    if (!context || Object.keys(context).sort().join(',') !== 'configPath,sourcePrefix') scopeFail('ENTROROVE_SCOPE_INPUT', 'Each import context requires sourcePrefix and configPath');
+    scopePath(context.sourcePrefix); scopePath(context.configPath);
+  }
+  const identity = { flowId: input.flowId, repositoryRoot: root, apiOrigin: dependencies.apiOrigin(), targetPaths, importContexts };
+  const parent = path.join(dependencies.home, '.entrorove');
+  await privateDirectory(parent);
+  const runners = path.join(parent, 'scope-runners'); await privateDirectory(runners);
+  const directory = path.join(runners, sha256(`${identity.apiOrigin}:${input.flowId}:${root}`)); await privateDirectory(directory);
+  return withStateLock(path.join(directory, 'connection'), () => connect(identity, directory, dependencies));
+}
+
+export async function runScopeConnect(repositoryRoot, input, dependencies) {
+  await dependencies.install();
+  if (!await dependencies.agreementAccepted(dependencies.home)) return dependencies.agreementRequired(dependencies.home);
+  try { return await connectScopeRunner(repositoryRoot, input, dependencies); }
+  catch (error) {
+    if (error.outcomeUnknown || !error.code?.startsWith('ENTROROVE_')) throw error;
+    return { schemaVersion: 'entrorove.scope-connection/1.0', status: 'blocked', flowId: input?.flowId,
+      code: error.code, message: error.message, ...(error.output ? { output: error.output } : {}) };
+  }
+}