cli-aimlock 7.0.34 → 7.0.36

package/README.md

@@ -23,7 +23,7 @@ When active, Aimlock uses Lock for one file through 500 changed lines and Probe
 - 把需求锁成可执行目标，阻止思考漂移、执行漂移、范围膨胀
 - Bypass / Lock / Probe / Swarm 分档：小改绕过；深度修改才进入门禁
 - 改前文件快照，禁止创建 git 分支
-- Lock / Probe / Swarm 分别强制 3 / 10 / 30 个文件与 2 / 8 / 15 分钟读取预算；Probe、Swarm 另有限制 30K / 100K 估算 token
+- Lock / Probe / Swarm 分别强制 3 / 10 / 30 个文件与 2 / 8 / 60 分钟读取预算；Probe、Swarm 另有限制 30K / 100K 估算 token
 - Ed25519 写入凭证绑定 chainId、快照摘要、路径集合和最长 300 秒有效期
 - `probe.targetSymbols` 可从新鲜的 ContextBase 项目地图解析真实目标文件；缺失、歧义或陈旧条目直接阻断
 - 服务端按当前需求实时发现专项技能，只返回命中项；非计算需求不出现 Calctool
@@ -43,7 +43,7 @@ cli-aimlock local gate-issue .
 cli-aimlock local guarded-write .
 ```
 
-每个命令从 stdin 读取 JSON。读取预算使用进程间原子锁，耗尽后只允许执行、输出方案或明确阻塞；追加预算必须携带 Confirm Protocol 的低风险确认回执。无凭证写入仅豁免 `.aimlock/logs/` 与 `.aimlock/tmp/`。
+每个命令从 stdin 读取 JSON。读取预算使用进程间原子锁，耗尽后只允许执行、输出方案或明确阻塞；文件/token 追加预算必须携带 Confirm Protocol 的低风险确认回执。长任务可先用 `budget-auto-renew-request` 生成目标、路径、续期间隔与次数上限，再凭一次真实回执调用 `budget-auto-renew`；同任务后续只自动续时间，累计额度与每次续期保留审计。达到次数/文件/token 上限仍明确阻断。撤销或完成时调用 `budget-auto-renew-stop`；本地执行链成功也会关闭预算。无凭证写入仅豁免 `.aimlock/logs/` 与 `.aimlock/tmp/`。
 
 Swarm 模式下，`chain-plan` 会在 `swarm` 前插入 `coordinator.conflict-scan`。`gate-issue` 必须显式声明 `coordinationRequired`；为 true 时凭证绑定 `.coord/leases/` 中的签名文件锁，`guarded-write` 在同一拦截点同时校验门禁与活动租约。存在活动 `dependency-wait` 的 chain 会被 `budget-read` 拒绝。
 

package/aimlock-chain-store.mjs

@@ -4,6 +4,7 @@ import { dirname, resolve } from 'node:path'
 import { setTimeout as delay } from 'node:timers/promises'
 import { atomicJson, ensureManagedDirectory, fail, identifier, repositoryRoot, resolvedProjectPath } from './aimlock-local-fs.mjs'
 import { STATE_SCHEMA, chainStatus, planDigest, validatePlan } from './aimlock-chain-model.mjs'
+import { completeReadBudgetIfExists } from './aimlock-read-budget-renewal.mjs'
 
 const LOCK_WAIT_MS = 2_000
 const LOCK_POLL_MS = 20
@@ -114,6 +115,7 @@ export async function saveExecution(file, state) {
   state.updatedAt = new Date().toISOString()
   state.status = chainStatus(state)
   await atomicJson(file, state)
+  if (state.status === 'succeeded') await completeReadBudgetIfExists(resolve(dirname(file), '../../..'), state.chainId)
 }
 
 export async function loadExecution(file) {

package/aimlock-local-runner.mjs

@@ -3,22 +3,15 @@ import {
   lstat,
   readFile,
   readdir,
-  writeFile,
 } from 'node:fs/promises'
 import { dirname, extname, relative, resolve } from 'node:path'
 import { promisify } from 'node:util'
 import {
   LOCAL_SCHEMA,
   appendAudit,
-  atomicJson,
-  ensureManagedDirectory,
   fail,
-  identifier,
-  managedPath,
   repositoryRoot,
   resolvedProjectPath,
-  safeRelativePath,
-  withFileLock,
 } from './aimlock-local-fs.mjs'
 import {
   PASS_SCHEMA,
@@ -27,24 +20,19 @@ import {
   verifyMutationPassFile,
 } from './aimlock-local-gate.mjs'
 import { resolveContextMapTargets } from './aimlock-context-map.mjs'
-import { assertChainNotSuspended } from './aimlock-coordination.mjs'
+import { BUDGET_SCHEMA, TOKEN_ESTIMATE_ALGORITHM, READ_BUDGETS, initializeReadBudget } from './aimlock-read-budget-state.mjs'
+import { checkCachedReadAccess, extendReadBudget, readBudgetStatus, readFileWithinBudget } from './aimlock-read-budget.mjs'
+import { authorizeReadBudgetRenewal, requestReadBudgetRenewal, stopReadBudgetRenewal } from './aimlock-read-budget-renewal.mjs'
+import { AUTO_RENEW_OPERATION_SCHEMAS } from './aimlock-read-budget-schemas.mjs'
 
 const execFile = promisify(execFileCallback)
-const BUDGET_SCHEMA = 'aimlock.read-budget/1.0'
-const CONFIRMATION_SCHEMA = 'confirm-protocol.skill.response/1.0'
 const MAX_DISCOVERED_FILES = 1_000
 const MAX_SOURCE_BYTES = 1_048_576
-const TOKEN_ESTIMATE_ALGORITHM = 'utf8-bytes-div-4-ceil'
 const SOURCE_EXTENSIONS = new Set(['.cjs', '.js', '.jsx', '.mjs', '.ts', '.tsx'])
 const IGNORED_DIRECTORIES = new Set([
   '.aimlock', '.git', '.runtime', 'coverage', 'dist', 'node_modules',
 ])
 const MODE_ORDER = Object.freeze(['lock', 'probe', 'swarm'])
-const READ_BUDGETS = Object.freeze({
-  lock: Object.freeze({ maxFiles: 3, maxTokenEstimate: null, maxDurationMs: 120_000 }),
-  probe: Object.freeze({ maxFiles: 10, maxTokenEstimate: 30_000, maxDurationMs: 480_000 }),
-  swarm: Object.freeze({ maxFiles: 30, maxTokenEstimate: 100_000, maxDurationMs: 900_000 }),
-})
 const HIGH_RISK_PATTERN = /生产数据|支付|用户隐私|密码|密钥|凭证|线上环境|production/i
 const IMPORT_PATTERN = /(?:import|export)\s+(?:[^'";]+?\s+from\s+)?['"]([^'"]+)['"]|require\(\s*['"]([^'"]+)['"]\s*\)/g
 const schema = (required, properties) => ({ type: 'object', additionalProperties: false,
@@ -67,6 +55,7 @@ const BUDGET_CONFIRMATION_SCHEMA = schema(['schemaVersion', 'requestId', 'status
   }), nextStep: objectValueSchema,
 })
 const LOCAL_OPERATION_SCHEMAS = Object.freeze({
+  ...AUTO_RENEW_OPERATION_SCHEMAS,
   capabilities: schema([], {}),
   probe: schema(['goal', 'targetHints'], { goal: stringSchema, targetHints: stringArraySchema,
     targetSymbols: { type: 'array', items: objectValueSchema } }),
@@ -266,167 +255,11 @@ function reassessMode(input) {
   }
 }
 
-async function readBudget(root, chainId) {
-  const id = identifier(chainId, 'chainId')
-  const path = managedPath(root, 'runs', id, 'read-budget.json')
-  const state = JSON.parse(await readFile(path, 'utf8'))
-  if (state.schemaVersion !== BUDGET_SCHEMA || state.chainId !== id) {
-    fail('AIMLOCK_BUDGET_INVALID', 'read budget authority is invalid')
-  }
-  return { path, state }
-}
-
-function budgetView(state, now = Date.now()) {
-  const elapsedMs = now - Date.parse(state.startedAt)
-  const remainingFiles = Math.max(0, state.maxFiles - state.uniqueFiles.length)
-  const remainingTokenEstimate = state.maxTokenEstimate === null ? null
-    : Math.max(0, state.maxTokenEstimate - state.tokenEstimate)
-  const remainingDurationMs = Math.max(0, state.maxDurationMs - elapsedMs)
-  const decisionRequired = remainingFiles === 0 || remainingDurationMs === 0
-    || remainingTokenEstimate === 0
-  return { ...state, elapsedMs, remainingFiles, remainingTokenEstimate, remainingDurationMs,
-    decisionRequired, nextActions: decisionRequired ? ['execute', 'plan', 'blocked'] : [] }
-}
-
-async function initializeReadBudget(input) {
-  const root = await repositoryRoot(input.repositoryRoot)
-  const chainId = identifier(input.chainId, 'chainId')
-  const limits = READ_BUDGETS[input.mode]
-  if (!limits) fail('AIMLOCK_MODE_INVALID', 'mode must be lock, probe, or swarm')
-  const directory = await ensureManagedDirectory(root, 'runs', chainId)
-  const state = {
-    schemaVersion: BUDGET_SCHEMA,
-    chainId,
-    mode: input.mode,
-    startedAt: new Date().toISOString(),
-    ...limits,
-    uniqueFiles: [],
-    readCalls: 0,
-    tokenEstimate: 0,
-    tokenEstimateAlgorithm: TOKEN_ESTIMATE_ALGORITHM,
-    extensions: [],
-  }
-  await writeFile(resolve(directory, 'read-budget.json'), `${JSON.stringify(state)}\n`, {
-    flag: 'wx', mode: 0o600,
-  })
-  await appendAudit(root, { event: 'read-budget-initialized', chainId, mode: input.mode })
-  return budgetView(state)
-}
-
-async function readFileWithinBudget(input) {
-  const root = await repositoryRoot(input.repositoryRoot)
-  const chainId = identifier(input.chainId, 'chainId')
-  await assertChainNotSuspended({ repositoryRoot: root, chainId })
-  const budgetPath = managedPath(root, 'runs', chainId, 'read-budget.json')
-  return withFileLock(budgetPath, async () => {
-    const authority = await readBudget(root, chainId)
-    const path = safeRelativePath(input.path)
-    const state = authority.state
-    const before = budgetView(state)
-    if (before.remainingDurationMs === 0) fail('AIMLOCK_DECISION_REQUIRED', 'read deadline exhausted')
-    const isNew = !state.uniqueFiles.includes(path)
-    if (isNew && before.remainingFiles === 0) fail('AIMLOCK_DECISION_REQUIRED', 'read file budget exhausted')
-    const projectFile = await resolvedProjectPath(root, path)
-    if (!projectFile.status.isFile()) fail('AIMLOCK_READ_NOT_FILE', `${path} is not a file`)
-    const tokenEstimate = Math.ceil(projectFile.status.size / 4)
-    if (before.remainingTokenEstimate !== null && tokenEstimate > before.remainingTokenEstimate) {
-      fail('AIMLOCK_DECISION_REQUIRED', 'read token estimate budget exhausted')
-    }
-    const content = await readFile(projectFile.target, 'utf8')
-    const updated = {
-      ...state,
-      uniqueFiles: isNew ? [...state.uniqueFiles, path] : state.uniqueFiles,
-      readCalls: state.readCalls + 1,
-      tokenEstimate: state.tokenEstimate + tokenEstimate,
-    }
-    await atomicJson(authority.path, updated)
-    await appendAudit(root, { event: 'read-consumed', chainId, path, tokenEstimate })
-    return { schemaVersion: LOCAL_SCHEMA, path, content, budget: budgetView(updated) }
-  })
-}
-
-async function checkCachedReadAccess(input) {
-  const root = await repositoryRoot(input.repositoryRoot)
-  const chainId = identifier(input.chainId, 'chainId')
-  await assertChainNotSuspended({ repositoryRoot: root, chainId })
-  const budgetPath = managedPath(root, 'runs', chainId, 'read-budget.json')
-  return withFileLock(budgetPath, async () => {
-    const { state } = await readBudget(root, chainId)
-    const path = safeRelativePath(input.path)
-    const budget = budgetView(state)
-    if (budget.remainingDurationMs === 0) fail('AIMLOCK_DECISION_REQUIRED', 'read deadline exhausted')
-    if (budget.remainingTokenEstimate === 0) fail('AIMLOCK_DECISION_REQUIRED', 'read token estimate budget exhausted')
-    if (!state.uniqueFiles.includes(path)) fail('AIMLOCK_CACHE_UNCHARGED', 'cached source was not read by this chain')
-    return { schemaVersion: LOCAL_SCHEMA, path, budget }
-  })
-}
-
-async function readBudgetStatus(input) {
-  const root = await repositoryRoot(input.repositoryRoot)
-  return budgetView((await readBudget(root, input.chainId)).state)
-}
-
-function confirmedBudgetExtension(input) {
-  const confirmation = input.confirmation
-  const audit = confirmation?.auditEntry
-  const callback = confirmation?.callbackRequest
-  const payload = callback?.payload
-  const fields = ['files', 'tokenEstimate', 'durationMs']
-  if (!confirmation || confirmation.schemaVersion !== CONFIRMATION_SCHEMA || confirmation.status !== 'succeeded'
-    || audit?.schemaVersion !== 'confirm.audit-entry/1.0' || audit.risk !== 'low' || audit.answer !== 'approve'
-    || typeof audit.remembered !== 'boolean' || !Number.isFinite(Date.parse(audit.answeredAt))
-    || callback?.operation !== 'budget-extend' || payload?.answer !== 'approve'
-    || payload.chainId !== input.chainId || payload.requestId !== audit.requestId
-    || !payload.additions || fields.some((key) => payload.additions[key] !== input.additions?.[key])) {
-    fail('AIMLOCK_CONFIRMATION_REQUIRED', 'a low-risk Confirm Protocol interaction-answer bound to this chain and exact additions is required')
-  }
-  identifier(audit.actorId, 'actorId')
-  identifier(audit.requestId, 'requestId')
-  return identifier(audit.auditId, 'auditId')
-}
-
-async function extendReadBudget(input) {
-  const root = await repositoryRoot(input.repositoryRoot)
-  const confirmationId = confirmedBudgetExtension(input)
-  const additions = input.additions
-  if (!additions || !Number.isSafeInteger(additions.files) || additions.files < 0
-    || !Number.isSafeInteger(additions.tokenEstimate) || additions.tokenEstimate < 0
-    || !Number.isSafeInteger(additions.durationMs) || additions.durationMs < 0
-    || additions.files + additions.tokenEstimate + additions.durationMs === 0) {
-    fail('AIMLOCK_EXTENSION_INVALID', 'budget additions must contain a positive integer increase')
-  }
-  const chainId = identifier(input.chainId, 'chainId')
-  const budgetPath = managedPath(root, 'runs', chainId, 'read-budget.json')
-  return withFileLock(budgetPath, async () => {
-    const authority = await readBudget(root, chainId)
-    const state = authority.state
-    if (state.extensions.some((item) => item.confirmationId === confirmationId)) {
-      fail('AIMLOCK_CONFIRMATION_REPLAYED', 'this budget confirmation has already been applied')
-    }
-    const updated = {
-      ...state,
-      maxFiles: state.maxFiles + additions.files,
-      maxTokenEstimate: state.maxTokenEstimate === null && additions.tokenEstimate === 0
-        ? null : (state.maxTokenEstimate ?? 0) + additions.tokenEstimate,
-      maxDurationMs: state.maxDurationMs + additions.durationMs,
-      extensions: [...state.extensions, {
-        confirmationId,
-        additions,
-        at: new Date().toISOString(),
-      }],
-    }
-    await atomicJson(authority.path, updated)
-    await appendAudit(root, { event: 'read-budget-extended', chainId,
-      confirmationId, additions })
-    return budgetView(updated)
-  })
-}
-
 const LOCAL_CAPABILITIES = Object.freeze({
   schemaVersion: LOCAL_SCHEMA,
   operations: Object.freeze([
     'capabilities', 'probe', 'reassess', 'budget-init', 'budget-read', 'budget-status',
-    'budget-extend', 'gate-issue', 'gate-verify', 'guarded-write',
+    'budget-extend', 'budget-auto-renew-request', 'budget-auto-renew', 'budget-auto-renew-stop', 'gate-issue', 'gate-verify', 'guarded-write',
   ]),
   operationSchemas: LOCAL_OPERATION_SCHEMAS,
   writeBoundary: 'Only writes routed through guarded-write are physically intercepted. The IDE host must route batch writes through this runner.',
@@ -442,6 +275,9 @@ export {
   LOCAL_SCHEMA,
   PASS_SCHEMA,
   READ_BUDGETS,
+  authorizeReadBudgetRenewal,
+  requestReadBudgetRenewal,
+  stopReadBudgetRenewal,
   checkCachedReadAccess,
   extendReadBudget,
   guardedWriteFile,

package/aimlock-read-budget-renewal.mjs

@@ -0,0 +1,198 @@
+import { readFile } from 'node:fs/promises'
+import { relative } from 'node:path'
+import { appendAudit, atomicJson, fail, identifier, managedPath, repositoryRoot,
+  resolvedProjectPath, safeRelativePath, sha256, withFileLock } from './aimlock-local-fs.mjs'
+import { readBudget, budgetView, requiredRenewalIntervals } from './aimlock-read-budget-state.mjs'
+
+const RENEWAL_SCHEMA = 'aimlock.read-budget-auto-renew/1.0'
+const MIN_INTERVAL_MS = 60_000
+const MAX_INTERVAL_MS = 86_400_000
+const MAX_RENEWALS = 1_000
+const RENEWAL_LIMITS = Object.freeze({ minIntervalMs: MIN_INTERVAL_MS,
+  maxIntervalMs: MAX_INTERVAL_MS, maxRenewals: MAX_RENEWALS })
+const RENEW_OPERATION = 'budget-auto-renew'
+const RENEWAL_REASON = 'authorized-read-deadline-expired'
+
+function renewalTerms(input) {
+  const chainId = identifier(input.chainId, 'chainId')
+  const scope = input.scope
+  const policy = input.policy
+  if (!scope || typeof scope.goal !== 'string' || !scope.goal.trim()
+    || !Array.isArray(scope.allowedPaths) || scope.allowedPaths.length === 0) {
+    fail('AIMLOCK_RENEWAL_SCOPE_INVALID', 'a goal and explicit repository-relative allowedPaths are required')
+  }
+  const paths = scope.allowedPaths.map((path) => {
+    const value = safeRelativePath(path)
+    if (/[*?\[\]{}]/.test(value)) fail('AIMLOCK_RENEWAL_SCOPE_INVALID', 'scope paths must be literal files or directories')
+    return value
+  })
+  if (!policy || !Number.isSafeInteger(policy.intervalMs) || policy.intervalMs < MIN_INTERVAL_MS
+    || policy.intervalMs > MAX_INTERVAL_MS || !Number.isSafeInteger(policy.maxRenewals)
+    || policy.maxRenewals < 1 || policy.maxRenewals > MAX_RENEWALS) {
+    fail('AIMLOCK_RENEWAL_POLICY_INVALID', 'intervalMs must be 60000..86400000; maxRenewals must be 1..1000')
+  }
+  const normalizedScope = { goal: scope.goal.trim(), allowedPaths: [...new Set(paths)].sort() }
+  return { chainId, scope: normalizedScope, scopeDigest: sha256(JSON.stringify(normalizedScope)),
+    policy: { intervalMs: policy.intervalMs, maxRenewals: policy.maxRenewals } }
+}
+
+function renewalQuestion(terms) {
+  return `Allow automatic read-time renewal for chain ${terms.chainId}? Goal: ${terms.scope.goal}. `
+    + `Read scope: ${terms.scope.allowedPaths.join(', ')}. Each renewal: ${terms.policy.intervalMs} ms; `
+    + `maximum: ${terms.policy.maxRenewals}; total additional time: ${terms.policy.intervalMs * terms.policy.maxRenewals} ms. `
+    + 'File, token and write limits remain unchanged. Revocation or task completion stops automatic renewal.'
+}
+
+async function requestReadBudgetRenewal(input) {
+  const terms = renewalTerms(input)
+  const root = await repositoryRoot(input.repositoryRoot)
+  const { state } = await readBudget(root, terms.chainId)
+  await assertReadBudgetActive(root, state)
+  const requestId = identifier(input.requestId, 'requestId')
+  return { schemaVersion: 'confirm.interaction/1.0', requestId, type: 'confirm',
+    question: renewalQuestion(terms), options: [{ id: 'approve', label: 'Approve' }, { id: 'decline', label: 'Decline' }],
+    default: null, timeout: null, timeoutAction: 'wait', risk: 'low', riskDescription: '',
+    rememberable: false, memoryKey: '', callback: { operation: RENEW_OPERATION,
+      payload: { chainId: terms.chainId, scopeDigest: terms.scopeDigest, policy: terms.policy } } }
+}
+
+function renewalReceipt(input, terms) {
+  const response = input.confirmation
+  const audit = response?.auditEntry
+  const callback = response?.callbackRequest
+  const payload = callback?.payload
+  if (response?.schemaVersion !== 'confirm-protocol.skill.response/1.0' || response.status !== 'succeeded'
+    || audit?.schemaVersion !== 'confirm.audit-entry/1.0' || audit.risk !== 'low'
+    || audit.answer !== 'approve' || audit.remembered !== false || !Number.isFinite(Date.parse(audit.answeredAt))
+    || audit.question !== renewalQuestion(terms) || callback?.operation !== RENEW_OPERATION
+    || payload?.answer !== 'approve' || payload.chainId !== terms.chainId || payload.requestId !== audit.requestId
+    || payload.scopeDigest !== terms.scopeDigest || payload.policy?.intervalMs !== terms.policy.intervalMs
+    || payload.policy?.maxRenewals !== terms.policy.maxRenewals) {
+    fail('AIMLOCK_CONFIRMATION_REQUIRED', 'a one-time Confirm Protocol approval bound to the chain, goal, scope and exact renewal policy is required')
+  }
+  identifier(response.requestId, 'confirmation.requestId')
+  return { confirmationId: identifier(audit.auditId, 'auditId'), actorId: identifier(audit.actorId, 'actorId'),
+    requestId: identifier(audit.requestId, 'requestId'), authorizedAt: audit.answeredAt }
+}
+
+async function authorizeReadBudgetRenewal(input) {
+  const terms = renewalTerms(input)
+  const receipt = renewalReceipt(input, terms)
+  const root = await repositoryRoot(input.repositoryRoot)
+  const budgetPath = managedPath(root, 'runs', terms.chainId, 'read-budget.json')
+  return withFileLock(budgetPath, async () => {
+    const { state } = await readBudget(root, terms.chainId)
+    await assertReadBudgetActive(root, state)
+    if (state.autoRenew) {
+      const replayed = state.autoRenew.confirmationId === receipt.confirmationId
+      fail(replayed ? 'AIMLOCK_CONFIRMATION_REPLAYED' : 'AIMLOCK_RENEWAL_ALREADY_AUTHORIZED',
+        'this chain already has an immutable renewal authorization; use the existing policy or an explicit budget extension')
+    }
+    for (const path of terms.scope.allowedPaths) {
+      const target = await resolvedProjectPath(root, path, { allowMissing: true })
+      if (relative(root, target.target).split('\\').join('/') !== path) {
+        fail('AIMLOCK_RENEWAL_SCOPE_INVALID', 'authorized paths must use their canonical repository location')
+      }
+    }
+    const updated = { ...state, autoRenew: { schemaVersion: RENEWAL_SCHEMA,
+      ...terms, ...receipt, status: 'active', renewalCount: 0, totalRenewedMs: 0, renewals: [] } }
+    await atomicJson(budgetPath, updated)
+    await appendAudit(root, { event: 'read-budget-auto-renew-authorized', ...terms, ...receipt })
+    return budgetView(updated)
+  })
+}
+
+async function executionCompleted(root, chainId) {
+  let source
+  try {
+    source = await readFile(managedPath(root, 'executions', chainId, 'state.json'), 'utf8')
+  } catch (error) {
+    if (error.code === 'ENOENT') return false
+    throw error
+  }
+  const execution = JSON.parse(source)
+  if (execution.chainId !== chainId || typeof execution.status !== 'string') {
+    fail('AIMLOCK_CHAIN_STATE_INVALID', 'execution lifecycle does not match the read-budget chain')
+  }
+  return execution.status === 'succeeded'
+}
+
+async function assertReadBudgetActive(root, state) {
+  if (state.completedAt || await executionCompleted(root, state.chainId)) {
+    fail('AIMLOCK_BUDGET_COMPLETED', 'this task is complete; read access and automatic renewal have stopped')
+  }
+}
+
+function assertRenewalScope(state, path, canonicalPath) {
+  if (!state.autoRenew) return
+  const paths = state.autoRenew.scope.allowedPaths
+  const covered = (target) => paths.some((allowed) => target === allowed || target.startsWith(`${allowed}/`))
+  if (!covered(path) || !covered(canonicalPath)) {
+    fail('AIMLOCK_RENEWAL_SCOPE_MISMATCH', 'source path is outside this task\'s approved read scope')
+  }
+}
+
+async function renewReadBudgetTime(root, authority, path) {
+  const state = authority.state
+  const now = Date.now()
+  const budget = budgetView(state, now)
+  if (budget.remainingDurationMs > 0) return state
+  const renewal = state.autoRenew
+  if (!renewal || renewal.status !== 'active') {
+    fail('AIMLOCK_DECISION_REQUIRED', `read deadline exhausted; automatic renewal ${renewal ? 'was stopped' : 'requires explicit approval via budget-auto-renew-request'}`)
+  }
+  if (budget.remainingFiles === 0 || budget.remainingTokenEstimate === 0) {
+    fail('AIMLOCK_DECISION_REQUIRED', 'file or token budget exhausted; time renewal cannot expand these limits')
+  }
+  const count = requiredRenewalIntervals(state, now)
+  if (count > renewal.policy.maxRenewals - renewal.renewalCount) {
+    fail('AIMLOCK_DECISION_REQUIRED', `automatic renewal limit exhausted: ${renewal.renewalCount}/${renewal.policy.maxRenewals} used; ${count} additional intervals required`)
+  }
+  const at = new Date(now).toISOString()
+  const records = Array.from({ length: count }, (_, index) => ({
+    count: renewal.renewalCount + index + 1, reason: RENEWAL_REASON, at, path,
+    durationMs: renewal.policy.intervalMs,
+    maxDurationMs: state.maxDurationMs + (index + 1) * renewal.policy.intervalMs,
+  }))
+  const addedMs = count * renewal.policy.intervalMs
+  const updated = { ...state, maxDurationMs: state.maxDurationMs + addedMs,
+    autoRenew: { ...renewal, renewalCount: renewal.renewalCount + count,
+      totalRenewedMs: renewal.totalRenewedMs + addedMs, renewals: [...renewal.renewals, ...records] } }
+  await atomicJson(authority.path, updated)
+  for (const record of records) await appendAudit(root, { event: 'read-budget-auto-renewed',
+    chainId: state.chainId, confirmationId: renewal.confirmationId, scopeDigest: renewal.scopeDigest, ...record })
+  return updated
+}
+
+async function stopReadBudgetRenewal(input) {
+  const root = await repositoryRoot(input.repositoryRoot)
+  const chainId = identifier(input.chainId, 'chainId')
+  if (!['revoked', 'completed'].includes(input.reason)) {
+    fail('AIMLOCK_RENEWAL_STOP_INVALID', 'reason must be revoked or completed')
+  }
+  return withFileLock(managedPath(root, 'runs', chainId, 'read-budget.json'), async () => {
+    const { state, path } = await readBudget(root, chainId)
+    if (state.completedAt || (input.reason === 'revoked' && state.autoRenew?.status === 'revoked')) return budgetView(state)
+    if (input.reason === 'revoked' && !state.autoRenew) {
+      fail('AIMLOCK_RENEWAL_NOT_AUTHORIZED', 'this task has no automatic renewal authorization to revoke')
+    }
+    const at = new Date().toISOString()
+    const updated = { ...state }
+    if (input.reason === 'completed') updated.completedAt = at
+    if (state.autoRenew) updated.autoRenew = { ...state.autoRenew, status: input.reason, stoppedAt: at }
+    await atomicJson(path, updated)
+    await appendAudit(root, { event: 'read-budget-auto-renew-stopped', chainId, reason: input.reason, at })
+    return budgetView(updated)
+  })
+}
+
+async function completeReadBudgetIfExists(root, chainId) {
+  try { await readBudget(root, chainId) } catch (error) {
+    if (error.code === 'ENOENT') return
+    throw error
+  }
+  await stopReadBudgetRenewal({ repositoryRoot: root, chainId, reason: 'completed' })
+}
+
+export { RENEWAL_LIMITS, authorizeReadBudgetRenewal, requestReadBudgetRenewal, stopReadBudgetRenewal,
+  assertReadBudgetActive, assertRenewalScope, renewReadBudgetTime, completeReadBudgetIfExists }

package/aimlock-read-budget-schemas.mjs

@@ -0,0 +1,31 @@
+import { RENEWAL_LIMITS } from './aimlock-read-budget-renewal.mjs'
+
+const stringSchema = { type: 'string', minLength: 1 }
+const objectSchema = (required, properties) => ({ type: 'object', additionalProperties: false, required, properties })
+const scopeSchema = objectSchema(['goal', 'allowedPaths'], { goal: stringSchema,
+  allowedPaths: { type: 'array', minItems: 1, items: stringSchema } })
+const policySchema = objectSchema(['intervalMs', 'maxRenewals'], {
+  intervalMs: { type: 'integer', minimum: RENEWAL_LIMITS.minIntervalMs, maximum: RENEWAL_LIMITS.maxIntervalMs },
+  maxRenewals: { type: 'integer', minimum: 1, maximum: RENEWAL_LIMITS.maxRenewals },
+})
+const confirmationSchema = objectSchema(['schemaVersion', 'requestId', 'status', 'callbackRequest', 'auditEntry', 'nextStep'], {
+  schemaVersion: { const: 'confirm-protocol.skill.response/1.0' }, requestId: stringSchema,
+  status: { const: 'succeeded' },
+  callbackRequest: objectSchema(['operation', 'payload'], { operation: { const: 'budget-auto-renew' },
+    payload: objectSchema(['chainId', 'scopeDigest', 'policy', 'requestId', 'answer'], {
+      chainId: stringSchema, scopeDigest: stringSchema, policy: policySchema, requestId: stringSchema, answer: { const: 'approve' },
+    }) }),
+  auditEntry: objectSchema(['schemaVersion', 'auditId', 'requestId', 'actorId', 'question', 'answer', 'remembered', 'risk', 'answeredAt'], {
+    schemaVersion: { const: 'confirm.audit-entry/1.0' }, auditId: stringSchema, requestId: stringSchema,
+    actorId: stringSchema, question: stringSchema, answer: { const: 'approve' }, remembered: { const: false },
+    risk: { const: 'low' }, answeredAt: { type: 'string', format: 'date-time' },
+  }), nextStep: { type: 'object' },
+})
+const terms = { chainId: stringSchema, scope: scopeSchema, policy: policySchema }
+const AUTO_RENEW_OPERATION_SCHEMAS = Object.freeze({
+  'budget-auto-renew-request': objectSchema(['chainId', 'scope', 'policy', 'requestId'], { ...terms, requestId: stringSchema }),
+  'budget-auto-renew': objectSchema(['chainId', 'scope', 'policy', 'confirmation'], { ...terms, confirmation: confirmationSchema }),
+  'budget-auto-renew-stop': objectSchema(['chainId', 'reason'], { chainId: stringSchema, reason: { enum: ['revoked', 'completed'] } }),
+})
+
+export { AUTO_RENEW_OPERATION_SCHEMAS }

package/aimlock-read-budget-state.mjs

@@ -0,0 +1,71 @@
+import { readFile, writeFile } from 'node:fs/promises'
+import { resolve } from 'node:path'
+import { appendAudit, ensureManagedDirectory, fail, identifier, managedPath, repositoryRoot } from './aimlock-local-fs.mjs'
+
+const BUDGET_SCHEMA = 'aimlock.read-budget/1.0'
+const TOKEN_ESTIMATE_ALGORITHM = 'utf8-bytes-div-4-ceil'
+const READ_BUDGETS = Object.freeze({
+  lock: Object.freeze({ maxFiles: 3, maxTokenEstimate: null, maxDurationMs: 120_000 }),
+  probe: Object.freeze({ maxFiles: 10, maxTokenEstimate: 30_000, maxDurationMs: 480_000 }),
+  swarm: Object.freeze({ maxFiles: 30, maxTokenEstimate: 100_000, maxDurationMs: 3_600_000 }),
+})
+
+async function readBudget(root, chainId) {
+  const id = identifier(chainId, 'chainId')
+  const path = managedPath(root, 'runs', id, 'read-budget.json')
+  const state = JSON.parse(await readFile(path, 'utf8'))
+  if (state.schemaVersion !== BUDGET_SCHEMA || state.chainId !== id) {
+    fail('AIMLOCK_BUDGET_INVALID', 'read budget authority is invalid')
+  }
+  return { path, state }
+}
+
+function budgetView(state, now = Date.now()) {
+  const elapsedMs = now - Date.parse(state.startedAt)
+  const remainingFiles = Math.max(0, state.maxFiles - state.uniqueFiles.length)
+  const remainingTokenEstimate = state.maxTokenEstimate === null ? null
+    : Math.max(0, state.maxTokenEstimate - state.tokenEstimate)
+  const remainingDurationMs = Math.max(0, state.maxDurationMs - elapsedMs)
+  const autoRenewEligible = !state.completedAt && remainingDurationMs === 0
+    && remainingFiles > 0 && remainingTokenEstimate !== 0 && state.autoRenew?.status === 'active'
+    && requiredRenewalIntervals(state, now) <= state.autoRenew.policy.maxRenewals - state.autoRenew.renewalCount
+  const decisionRequired = Boolean(state.completedAt) || remainingFiles === 0 || (remainingDurationMs === 0 && !autoRenewEligible)
+    || remainingTokenEstimate === 0
+  return { ...state, elapsedMs, remainingFiles, remainingTokenEstimate, remainingDurationMs,
+    autoRenewEligible, decisionRequired,
+    nextActions: decisionRequired ? ['execute', 'plan', 'blocked'] : autoRenewEligible ? ['budget-read'] : [] }
+}
+
+function requiredRenewalIntervals(state, now = Date.now()) {
+  if (!state.autoRenew) return null
+  return Math.max(0, Math.floor((now - Date.parse(state.startedAt) - state.maxDurationMs)
+    / state.autoRenew.policy.intervalMs) + 1)
+}
+
+async function initializeReadBudget(input) {
+  const root = await repositoryRoot(input.repositoryRoot)
+  const chainId = identifier(input.chainId, 'chainId')
+  const limits = READ_BUDGETS[input.mode]
+  if (!limits) fail('AIMLOCK_MODE_INVALID', 'mode must be lock, probe, or swarm')
+  const directory = await ensureManagedDirectory(root, 'runs', chainId)
+  const state = {
+    schemaVersion: BUDGET_SCHEMA,
+    chainId,
+    mode: input.mode,
+    startedAt: new Date().toISOString(),
+    ...limits,
+    uniqueFiles: [],
+    readCalls: 0,
+    tokenEstimate: 0,
+    tokenEstimateAlgorithm: TOKEN_ESTIMATE_ALGORITHM,
+    extensions: [],
+  }
+  await writeFile(resolve(directory, 'read-budget.json'), `${JSON.stringify(state)}\n`, {
+    flag: 'wx', mode: 0o600,
+  })
+  await appendAudit(root, { event: 'read-budget-initialized', chainId, mode: input.mode })
+  return budgetView(state)
+}
+
+export { BUDGET_SCHEMA, TOKEN_ESTIMATE_ALGORITHM, READ_BUDGETS, readBudget, budgetView,
+  requiredRenewalIntervals, initializeReadBudget }

package/aimlock-read-budget.mjs

@@ -0,0 +1,127 @@
+import { readFile } from 'node:fs/promises'
+import { relative } from 'node:path'
+import { LOCAL_SCHEMA, appendAudit, atomicJson, fail, identifier, managedPath,
+  repositoryRoot, resolvedProjectPath, safeRelativePath, withFileLock } from './aimlock-local-fs.mjs'
+import { assertChainNotSuspended } from './aimlock-coordination.mjs'
+import { readBudget, budgetView } from './aimlock-read-budget-state.mjs'
+import { assertReadBudgetActive, assertRenewalScope, renewReadBudgetTime } from './aimlock-read-budget-renewal.mjs'
+
+const CONFIRMATION_SCHEMA = 'confirm-protocol.skill.response/1.0'
+
+async function readFileWithinBudget(input) {
+  const root = await repositoryRoot(input.repositoryRoot)
+  const chainId = identifier(input.chainId, 'chainId')
+  await assertChainNotSuspended({ repositoryRoot: root, chainId })
+  const budgetPath = managedPath(root, 'runs', chainId, 'read-budget.json')
+  return withFileLock(budgetPath, async () => {
+    const authority = await readBudget(root, chainId)
+    const path = safeRelativePath(input.path)
+    let state = authority.state
+    await assertReadBudgetActive(root, state)
+    const before = budgetView(state)
+    const isNew = !state.uniqueFiles.includes(path)
+    if (isNew && before.remainingFiles === 0) fail('AIMLOCK_DECISION_REQUIRED', 'read file budget exhausted')
+    const projectFile = await resolvedProjectPath(root, path)
+    if (!projectFile.status.isFile()) fail('AIMLOCK_READ_NOT_FILE', `${path} is not a file`)
+    assertRenewalScope(state, path, relative(root, projectFile.target).split('\\').join('/'))
+    const tokenEstimate = Math.ceil(projectFile.status.size / 4)
+    if (before.remainingTokenEstimate !== null && tokenEstimate > before.remainingTokenEstimate) {
+      fail('AIMLOCK_DECISION_REQUIRED', 'read token estimate budget exhausted')
+    }
+    state = await renewReadBudgetTime(root, authority, path)
+    const content = await readFile(projectFile.target, 'utf8')
+    const updated = {
+      ...state,
+      uniqueFiles: isNew ? [...state.uniqueFiles, path] : state.uniqueFiles,
+      readCalls: state.readCalls + 1,
+      tokenEstimate: state.tokenEstimate + tokenEstimate,
+    }
+    await atomicJson(authority.path, updated)
+    await appendAudit(root, { event: 'read-consumed', chainId, path, tokenEstimate })
+    return { schemaVersion: LOCAL_SCHEMA, path, content, budget: budgetView(updated) }
+  })
+}
+
+async function checkCachedReadAccess(input) {
+  const root = await repositoryRoot(input.repositoryRoot)
+  const chainId = identifier(input.chainId, 'chainId')
+  await assertChainNotSuspended({ repositoryRoot: root, chainId })
+  const budgetPath = managedPath(root, 'runs', chainId, 'read-budget.json')
+  return withFileLock(budgetPath, async () => {
+    const authority = await readBudget(root, chainId)
+    const { state } = authority
+    await assertReadBudgetActive(root, state)
+    const path = safeRelativePath(input.path)
+    const budget = budgetView(state)
+    if (budget.remainingTokenEstimate === 0) fail('AIMLOCK_DECISION_REQUIRED', 'read token estimate budget exhausted')
+    if (!state.uniqueFiles.includes(path)) fail('AIMLOCK_CACHE_UNCHARGED', 'cached source was not read by this chain')
+    const projectFile = await resolvedProjectPath(root, path)
+    assertRenewalScope(state, path, relative(root, projectFile.target).split('\\').join('/'))
+    return { schemaVersion: LOCAL_SCHEMA, path,
+      budget: budgetView(await renewReadBudgetTime(root, authority, path)) }
+  })
+}
+
+async function readBudgetStatus(input) {
+  const root = await repositoryRoot(input.repositoryRoot)
+  return budgetView((await readBudget(root, input.chainId)).state)
+}
+
+function confirmedBudgetExtension(input) {
+  const confirmation = input.confirmation
+  const audit = confirmation?.auditEntry
+  const callback = confirmation?.callbackRequest
+  const payload = callback?.payload
+  const fields = ['files', 'tokenEstimate', 'durationMs']
+  if (!confirmation || confirmation.schemaVersion !== CONFIRMATION_SCHEMA || confirmation.status !== 'succeeded'
+    || audit?.schemaVersion !== 'confirm.audit-entry/1.0' || audit.risk !== 'low' || audit.answer !== 'approve'
+    || typeof audit.remembered !== 'boolean' || !Number.isFinite(Date.parse(audit.answeredAt))
+    || callback?.operation !== 'budget-extend' || payload?.answer !== 'approve'
+    || payload.chainId !== input.chainId || payload.requestId !== audit.requestId
+    || !payload.additions || fields.some((key) => payload.additions[key] !== input.additions?.[key])) {
+    fail('AIMLOCK_CONFIRMATION_REQUIRED', 'a low-risk Confirm Protocol interaction-answer bound to this chain and exact additions is required')
+  }
+  identifier(audit.actorId, 'actorId')
+  identifier(audit.requestId, 'requestId')
+  return identifier(audit.auditId, 'auditId')
+}
+
+async function extendReadBudget(input) {
+  const root = await repositoryRoot(input.repositoryRoot)
+  const confirmationId = confirmedBudgetExtension(input)
+  const additions = input.additions
+  if (!additions || !Number.isSafeInteger(additions.files) || additions.files < 0
+    || !Number.isSafeInteger(additions.tokenEstimate) || additions.tokenEstimate < 0
+    || !Number.isSafeInteger(additions.durationMs) || additions.durationMs < 0
+    || additions.files + additions.tokenEstimate + additions.durationMs === 0) {
+    fail('AIMLOCK_EXTENSION_INVALID', 'budget additions must contain a positive integer increase')
+  }
+  const chainId = identifier(input.chainId, 'chainId')
+  const budgetPath = managedPath(root, 'runs', chainId, 'read-budget.json')
+  return withFileLock(budgetPath, async () => {
+    const authority = await readBudget(root, chainId)
+    const state = authority.state
+    await assertReadBudgetActive(root, state)
+    if (state.extensions.some((item) => item.confirmationId === confirmationId)) {
+      fail('AIMLOCK_CONFIRMATION_REPLAYED', 'this budget confirmation has already been applied')
+    }
+    const updated = {
+      ...state,
+      maxFiles: state.maxFiles + additions.files,
+      maxTokenEstimate: state.maxTokenEstimate === null && additions.tokenEstimate === 0
+        ? null : (state.maxTokenEstimate ?? 0) + additions.tokenEstimate,
+      maxDurationMs: state.maxDurationMs + additions.durationMs,
+      extensions: [...state.extensions, {
+        confirmationId,
+        additions,
+        at: new Date().toISOString(),
+      }],
+    }
+    await atomicJson(authority.path, updated)
+    await appendAudit(root, { event: 'read-budget-extended', chainId,
+      confirmationId, additions })
+    return budgetView(updated)
+  })
+}
+
+export { checkCachedReadAccess, extendReadBudget, readBudgetStatus, readFileWithinBudget }

package/aimlock-runtime.mjs

@@ -209,7 +209,7 @@ const RESPONSE_SCHEMA = "aimlock.skill.response/1.1";
 const ERROR_SCHEMA = "aimlock.skill.error/1.0";
 const CONTRACT_SCHEMA = "aimlock.scope-contract/1.0";
 const COMPILER_NAME = "aimlock";
-const COMPILER_VERSION = "v7.0.34";
+const COMPILER_VERSION = "v7.0.36";
 const KEEP_ALIVE_SECONDS = 90;
 const KEEP_ALIVE_MESSAGE = "智能目标持续执行中，请勿关闭！";
 const BYPASS_LINE_BUDGET = 500;
@@ -1330,7 +1330,7 @@ async function executeRun(request) {
         localTrustedExecution: {
           requiredFor: ["filesystem-probe", "read-budget", "mutate-pass", "guarded-write", "autocoord-lease"],
           operations: ["capabilities", "probe", "reassess", "budget-init", "budget-read", "budget-status",
-            "budget-extend", "gate-issue", "gate-verify", "guarded-write"],
+            "budget-extend", "budget-auto-renew-request", "budget-auto-renew", "budget-auto-renew-stop", "gate-issue", "gate-verify", "guarded-write"],
           command: "cli-aimlock local <operation> <repositoryRoot>",
           schemaDiscovery: "cli-aimlock local capabilities <repositoryRoot>",
           boundary: "Only host writes routed through guarded-write are physically intercepted.",

package/brain-client-files.mjs

@@ -0,0 +1,88 @@
+import { createHash } from 'node:crypto'
+import { constants } from 'node:fs'
+import { lstat, open, realpath, mkdir, writeFile, readFile } from 'node:fs/promises'
+import { relative, resolve, isAbsolute } from 'node:path'
+
+const MAX_FILE_BYTES = 2_000_000
+const MAX_CONTEXT_CHARACTERS = 6_000
+export function validateBrainPath(path) {
+  if (typeof path !== 'string' || !path || path.length > 500 || isAbsolute(path)
+    || /[\\:\u0000-\u001f\u007f]/.test(path) || path.split('/').some((part) => !part || part === '.' || part === '..')
+    || /(?:^|\/)(?:\.env(?:\.[^/]*)?|\.git|\.ssh|node_modules|id_rsa|id_ed25519)(?:\/|$)|\.(?:pem|p12|key)$/i.test(path)) {
+    throw new Error('Brain target must be a safe relative project file')
+  }
+}
+
+async function checkedAncestors(root, path) {
+  const canonicalRoot = await realpath(root)
+  let current = canonicalRoot
+  for (const part of path.split('/').slice(0, -1)) {
+    current = resolve(current, part)
+    let status
+    try { status = await lstat(current) }
+    catch (error) { if (error.code === 'ENOENT') continue; throw error }
+    if (!status.isDirectory() || status.isSymbolicLink()) throw new Error('Brain target has an unsafe parent')
+  }
+  return canonicalRoot
+}
+
+export async function inspectBrainTarget(root, path) {
+  validateBrainPath(path)
+  const canonicalRoot = await checkedAncestors(root, path)
+  const target = resolve(canonicalRoot, path)
+  let status
+  try { status = await lstat(target) }
+  catch (error) { if (error.code === 'ENOENT') return { path, sha256: null, context: '' }; throw error }
+  if (!status.isFile() || status.isSymbolicLink() || status.size > MAX_FILE_BYTES) throw new Error('Brain target is not a bounded regular file')
+  const file = await open(target, constants.O_RDONLY | constants.O_NOFOLLOW)
+  try {
+    const opened = await file.stat()
+    if (opened.dev !== status.dev || opened.ino !== status.ino || !opened.isFile()) throw new Error('Brain target changed during inspection')
+    const bytes = Buffer.alloc(MAX_FILE_BYTES + 1)
+    let length = 0
+    while (length < bytes.length) {
+      const chunk = await file.read(bytes, length, bytes.length - length, length)
+      if (!chunk.bytesRead) break
+      length += chunk.bytesRead
+    }
+    if (length > MAX_FILE_BYTES) throw new Error('Brain target exceeds the file limit')
+    const final = await lstat(target)
+    const inside = relative(canonicalRoot, await realpath(target))
+    if (inside === '..' || inside.startsWith('../') || isAbsolute(inside)
+      || final.dev !== opened.dev || final.ino !== opened.ino || final.mtimeMs !== opened.mtimeMs) {
+      throw new Error('Brain target changed during inspection')
+    }
+    const contents = bytes.subarray(0, length)
+    if (contents.includes(0)) throw new Error('Brain context must be a text file')
+    return { path, sha256: createHash('sha256').update(contents).digest('hex'),
+      context: contents.toString('utf8').slice(0, MAX_CONTEXT_CHARACTERS) }
+  } finally { await file.close() }
+}
+
+export async function brainStateDirectory(root, parts) {
+  const canonicalRoot = await realpath(root)
+  let directory = canonicalRoot
+  for (const part of ['.aimlock', ...parts]) {
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(part) && part !== '.aimlock') throw new Error('Brain state path is invalid')
+    directory = resolve(directory, part)
+    try { await mkdir(directory, { mode: 0o700 }) }
+    catch (error) { if (error.code !== 'EEXIST') throw error }
+    const status = await lstat(directory)
+    if (!status.isDirectory() || status.isSymbolicLink()) throw new Error('Brain state directory is unsafe')
+  }
+  return directory
+}
+
+export async function saveBrainRequest(root, request, digest) {
+  const directory = await brainStateDirectory(root, ['brain-requests'])
+  const path = resolve(directory, request.requestId + '.json')
+  try { await writeFile(path, JSON.stringify(request), { mode: 0o600, flag: 'wx' }) }
+  catch (error) {
+    if (error.code !== 'EEXIST') throw error
+    const status = await lstat(path)
+    if (!status.isFile() || status.isSymbolicLink() || status.size > MAX_FILE_BYTES) throw new Error('Saved Brain request is unsafe')
+    if (digest(JSON.parse(await readFile(path, 'utf8'))) !== digest(request)) {
+      throw new Error('Brain request ID is already bound to different local input')
+    }
+  }
+}

package/brain-client.mjs

@@ -0,0 +1,170 @@
+import { createHash, randomUUID } from 'node:crypto'
+import { readFile, writeFile } from 'node:fs/promises'
+import { inspectBrainTarget, brainStateDirectory, saveBrainRequest } from './brain-client-files.mjs'
+export { inspectBrainTarget } from './brain-client-files.mjs'
+import { resolve } from 'node:path'
+import { brainClientAuthorization, transportFailureCode } from './broker.mjs'
+import { executeCommand } from './aimlock-chain-process.mjs'
+
+export const BRAIN_ENDPOINT = 'https://cli.tax/api/v1/brain'
+const REQUEST_SCHEMA = 'brain.planning-request/1.0'
+const RESPONSE_SCHEMA = 'brain.planning-response/1.0'
+const PLAN_SCHEMA = 'brain.execution-plan/1.0'
+const MAX_INPUT_BYTES = 256_000
+const TIMEOUT_MS = 120_000
+const HASH_PATTERN = /^[0-9a-f]{64}$/
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+const OPERATIONS = new Set(['plan', 'status', 'report', 'validate'])
+
+export function canonicalBrainJson(value) {
+  if (value === null || typeof value === 'string' || typeof value === 'boolean') return JSON.stringify(value)
+  if (typeof value === 'number' && Number.isFinite(value)) return JSON.stringify(value)
+  if (Array.isArray(value)) return '[' + value.map(canonicalBrainJson).join(',') + ']'
+  if (!value || typeof value !== 'object') throw new Error('Brain protocol value must be JSON')
+  return '{' + Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)
+    .map(([key, item]) => JSON.stringify(key) + ':' + canonicalBrainJson(item)).join(',') + '}'
+}
+
+export function brainClientDigest(value) {
+  return createHash('sha256').update(canonicalBrainJson(value)).digest('hex')
+}
+
+function exact(value, keys, label) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)
+    || Object.keys(value).some((key) => !keys.includes(key))
+    || keys.some((key) => !Object.hasOwn(value, key))) throw new Error(label + ' has invalid fields')
+}
+
+export async function invokeBrain(operation, input, dependencies = {}) {
+  if (!OPERATIONS.has(operation)) throw new Error('Unknown Brain operation')
+  const endpoint = dependencies.endpoint ?? BRAIN_ENDPOINT
+  const context = { endpoint, displayName: 'Brain planning' }
+  const environment = dependencies.environment ?? process.env
+  const authorization = await brainClientAuthorization(context, environment, dependencies.credentialAccess)
+  const body = JSON.stringify({ operation, input })
+  if (Buffer.byteLength(body) > MAX_INPUT_BYTES) throw new Error('Brain request exceeds the size limit')
+  let response
+  try {
+    response = await (dependencies.request ?? fetch)(endpoint, {
+      method: 'POST', redirect: 'error', headers: { Authorization: authorization, 'Content-Type': 'application/json' },
+      body, signal: AbortSignal.timeout(TIMEOUT_MS),
+    })
+  } catch (error) {
+    throw new Error('Brain transport failed (' + transportFailureCode(error) + '); query status before submitting another plan')
+  }
+  const payload = await readBrainResponse(response)
+  if (!response.ok) {
+    const code = typeof payload?.code === 'string' ? payload.code : 'BRAIN_HTTP_ERROR'
+    throw new Error('Brain request failed: HTTP ' + response.status + ' (' + code + ')')
+  }
+  if (payload?.schemaVersion !== RESPONSE_SCHEMA || !UUID_PATTERN.test(payload.planId)
+    || !UUID_PATTERN.test(payload.requestId)
+    || !['planning', 'ready', 'reported', 'verified', 'failed', 'expired'].includes(payload.status)) {
+    throw new Error('Brain response envelope is invalid')
+  }
+  if ((operation === 'plan' && payload.requestId !== input.requestId)
+    || (operation !== 'plan' && (input.planId ? payload.planId !== input.planId : payload.requestId !== input.requestId))) throw new Error('Brain response identity does not match')
+  if (payload.plan !== null && (payload.plan?.schemaVersion !== PLAN_SCHEMA
+    || payload.plan.planId !== payload.planId || !HASH_PATTERN.test(payload.planDigest)
+    || brainClientDigest(payload.plan) !== payload.planDigest)) throw new Error('Brain response plan digest is invalid')
+  return payload
+}
+
+export async function prepareBrainRequest(root, specification) {
+  exact(specification, ['requestId', 'goal', 'maxChangedLines', 'targets', 'checks'], 'Brain specification')
+  if (!UUID_PATTERN.test(specification.requestId) || typeof specification.goal !== 'string' || !specification.goal.trim()
+    || !Number.isSafeInteger(specification.maxChangedLines) || specification.maxChangedLines < 1
+    || !Array.isArray(specification.targets) || !specification.targets.length || specification.targets.length > 64
+    || new Set(specification.targets).size !== specification.targets.length) throw new Error('Brain specification is invalid')
+  const targets = []
+  for (const path of specification.targets) targets.push(await inspectBrainTarget(root, path))
+  return { schemaVersion: REQUEST_SCHEMA, ...specification, targets }
+}
+
+export function validateBrainHandoff(request, response) {
+  const plan = response.plan
+  if (response.status !== 'ready' || plan?.schemaVersion !== PLAN_SCHEMA || response.requestId !== request.requestId
+    || response.planId !== plan.planId || brainClientDigest(plan) !== response.planDigest) throw new Error('Brain plan is not ready')
+  const targets = request.targets.map(({ path, sha256 }) => ({ path, sha256 }))
+  if (brainClientDigest(plan.targets) !== brainClientDigest(targets)
+    || brainClientDigest(plan.checks) !== brainClientDigest(request.checks)
+    || brainClientDigest(plan.contract.allowedPaths) !== brainClientDigest(targets.map((target) => target.path))
+    || plan.contract.maxChangedLines !== request.maxChangedLines || plan.contract.allowDeleteFiles !== false) {
+    throw new Error('Brain plan changed the local authorization')
+  }
+  if (!Array.isArray(plan.nodes) || !plan.nodes.length
+    || plan.nodes.some((node) => !targets.some((target) => target.path === node.path))) throw new Error('Brain plan targets are invalid')
+  return plan
+}
+
+export async function collectBrainReport(root, handoff, environment = process.env) {
+  exact(handoff, ['request', 'response'], 'Brain handoff')
+  const plan = validateBrainHandoff(handoff.request, handoff.response)
+  if (typeof environment.PATH !== 'string' || !environment.PATH) throw new Error('Execution PATH is required')
+  const reportId = randomUUID()
+  const directory = await brainStateDirectory(root, ['brain-reports', reportId])
+  const evidence = []
+  for (const check of plan.checks) {
+    exact(check, ['id', 'executable', 'args', 'timeoutMs'], 'Brain check')
+    if (typeof check.id !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,79}$/.test(check.id)
+      || typeof check.executable !== 'string' || !check.executable
+      || !Array.isArray(check.args) || check.args.some((arg) => typeof arg !== 'string')
+      || !Number.isSafeInteger(check.timeoutMs) || check.timeoutMs < 1_000 || check.timeoutMs > 3_600_000) {
+      throw new Error('Brain check command is invalid')
+    }
+    const result = await executeCommand(root, {
+      executable: check.executable, args: check.args, timeoutMs: check.timeoutMs,
+      environment: { PATH: environment.PATH }, workingDirectory: '.', evidenceKind: 'test',
+    }, reportId + ':' + check.id, async () => {})
+    const digest = (value) => createHash('sha256').update(value).digest('hex')
+    evidence.push({ checkId: check.id, exitCode: result.status !== 'succeeded' && result.exitCode === 0 ? null : result.exitCode, durationMs: result.durationMs,
+      stdoutSha256: digest(result.stdout), stderrSha256: digest(result.stderr) })
+    await writeFile(resolve(directory, check.id + '.json'), JSON.stringify(result), { mode: 0o600 })
+    if (result.status === 'uncertain') throw new Error('Check process cleanup is unconfirmed; execution stopped')
+  }
+  const files = []
+  for (const node of plan.nodes) {
+    const actual = await inspectBrainTarget(root, node.path)
+    if (actual.sha256 === null) throw new Error('Planned file is missing: ' + node.path)
+    files.push({ path: node.path, sha256: actual.sha256 })
+  }
+  return { planId: plan.planId, planDigest: handoff.response.planDigest, reportId, files, evidence }
+}
+
+export async function runBrainCli(args) {
+  const [operation, root, file] = args
+  if (!['plan', 'check', 'status', 'validate'].includes(operation) || !root || !file || args.length !== 3) {
+    throw new Error('Usage: cli-aimlock brain <plan|check|status|validate> <repositoryRoot> <jsonFile>')
+  }
+  const source = await readFile(resolve(file), 'utf8')
+  if (Buffer.byteLength(source) > MAX_INPUT_BYTES) throw new Error('Brain input file exceeds the size limit')
+  const input = JSON.parse(source)
+  if (operation === 'plan') {
+    const request = await prepareBrainRequest(root, input)
+    await saveBrainRequest(root, request, brainClientDigest)
+    const response = await invokeBrain('plan', request)
+    if (response.status === 'ready') validateBrainHandoff(request, response)
+    process.stdout.write(JSON.stringify({ request, response }) + '\n')
+    return
+  }
+  const payload = operation === 'check' ? await collectBrainReport(root, input) : input
+  const response = await invokeBrain(operation === 'check' ? 'report' : operation, payload)
+  process.stdout.write(JSON.stringify(response) + '\n')
+}
+
+async function readBrainResponse(response) {
+  if (!response.body) throw new Error('Brain response body is missing')
+  const reader = response.body.getReader()
+  const chunks = []
+  let bytes = 0
+  try {
+    for (;;) {
+      const chunk = await reader.read()
+      if (chunk.done) break
+      bytes += chunk.value.byteLength
+      if (bytes > MAX_INPUT_BYTES) { await reader.cancel(); throw new Error('Brain response exceeds the size limit') }
+      chunks.push(Buffer.from(chunk.value))
+    }
+  } finally { reader.releaseLock() }
+  return JSON.parse(Buffer.concat(chunks).toString('utf8'))
+}

package/cli.mjs

@@ -4,10 +4,14 @@ import { dirname, resolve } from 'node:path'
 import { cwd, stdin, stdout } from 'node:process'
 import { createInterface } from 'node:readline/promises'
 import { fileURLToPath } from 'node:url'
+import { runBrainCli } from './brain-client.mjs'
 import { CHAIN_USAGE, runChainCli } from './aimlock-chain-cli.mjs'
 import { defaultUsage, dispatchOfficialSkillCli, runIntakeHandshake } from './installer.mjs'
 import {
   LOCAL_CAPABILITIES,
+  authorizeReadBudgetRenewal,
+  requestReadBudgetRenewal,
+  stopReadBudgetRenewal,
   extendReadBudget,
   guardedWriteFile,
   initializeReadBudget,
@@ -92,6 +96,8 @@ export function aimlockUsage(context) {
   const usage = defaultUsage(context)
   if (!usage.includes(COMMON_RUN_USAGE)) throw new Error('Shared CLI run usage contract changed')
   return usage.replace(COMMON_RUN_USAGE, AIMLOCK_RUN_USAGE) + '\n\n' + CHAIN_USAGE
+    + '\n\nRead-time renewal: local budget-auto-renew-request <repositoryRoot> prepares one Confirm Protocol approval;'
+    + '\nlocal budget-auto-renew activates the approved chain/scope/policy; budget-auto-renew-stop revokes or completes it.'
 }
 
 async function collectApplicability(input, output) {
@@ -168,6 +174,9 @@ async function runLocalOperation(operation, repositoryRoot, input) {
   if (operation === 'budget-read') return readFileWithinBudget(scoped)
   if (operation === 'budget-status') return readBudgetStatus(scoped)
   if (operation === 'budget-extend') return extendReadBudget(scoped)
+  if (operation === 'budget-auto-renew-request') return requestReadBudgetRenewal(scoped)
+  if (operation === 'budget-auto-renew') return authorizeReadBudgetRenewal(scoped)
+  if (operation === 'budget-auto-renew-stop') return stopReadBudgetRenewal(scoped)
   if (operation === 'gate-issue') return issueMutationPass(scoped)
   if (operation === 'gate-verify') return verifyMutationPassFile(scoped)
   if (operation === 'guarded-write') return guardedWriteFile(scoped)
@@ -185,7 +194,9 @@ async function dispatchLocal(args) {
 
 const cliPath = fileURLToPath(import.meta.url)
 if (process.argv[1] && realpathSync(resolve(process.argv[1])) === cliPath) {
-  if (process.argv[2] === 'chain') {
+  if (process.argv[2] === 'brain') {
+    await runBrainCli(process.argv.slice(3))
+  } else if (process.argv[2] === 'chain') {
     await runChainCli(process.argv.slice(3))
   } else if (process.argv[2] === 'local') {
     try {

package/package.json

@@ -3,14 +3,15 @@
     "cli-aimlock": "./cli.mjs"
   },
   "dependencies": {
-    "cli-swarm": "7.0.34"
+    "cli-swarm": "7.0.36"
   },
   "description": "Aimlock skill installer for CLI.Tax: lock a user request into an executable aim and route Blueprint, Swarm, and Calctool.",
   "exports": {
     "./coordination": "./aimlock-coordination.mjs",
     "./local-runner": "./aimlock-local-runner.mjs",
     "./runtime": "./aimlock-runtime.mjs",
-    "./chain-executor": "./aimlock-chain-executor.mjs"
+    "./chain-executor": "./aimlock-chain-executor.mjs",
+    "./brain-client": "./brain-client.mjs"
   },
   "files": [
     "cli.mjs",
@@ -32,7 +33,13 @@
     "aimlock-local-fs.mjs",
     "aimlock-local-gate.mjs",
     "aimlock-local-runner.mjs",
+    "aimlock-read-budget-state.mjs",
+    "aimlock-read-budget.mjs",
+    "aimlock-read-budget-renewal.mjs",
+    "aimlock-read-budget-schemas.mjs",
     "aimlock-runtime.mjs",
+    "brain-client.mjs",
+    "brain-client-files.mjs",
     "skill/references/chain-executor.md"
   ],
   "license": "UNLICENSED",
@@ -42,5 +49,5 @@
     "url": "https://github.com/88208555/aimlock-clitax.git"
   },
   "type": "module",
-  "version": "7.0.34"
+  "version": "7.0.36"
 }

package/skill/SKILL.md

@@ -5,7 +5,7 @@ description: "Aimlock 仅用于大型、深度、跨模块、高风险、需要
 
 # Aimlock Skill
 
-Package version: v7.0.34
+Package version: v7.0.36
 
 Endpoint: https://cli.tax/R3mQ8kWpXn
 
@@ -64,7 +64,7 @@ Only after the applicability gate activates Aimlock:
 1. Call local `capabilities`, then `probe`; use only its filesystem, Git-history, package-boundary, and import-graph facts for the initial mode. Exact `targetSymbols` may resolve through a fresh ContextBase map; missing, ambiguous, or stale map entries block.
 2. Call remote `capabilities`, `intake`, and `classify`. A fallback `bypass` response stops the Aimlock chain.
 3. Call `scope-contract`; empty allowed paths are blocked. Initialize the mode's local read budget before exploration.
-4. Route every source read through local `budget-read`. Exhaustion requires `execute`, `plan`, or `blocked`; only a low-risk Confirm Protocol receipt may extend it.
+4. Route every source read through local `budget-read`. File/token exhaustion requires `execute`, `plan`, or `blocked`, or an exact Confirm Protocol budget extension. Time may renew automatically only after the one-time task-bound approval described below.
 5. Call `skill-route`. The server queries the current published official directory and injects only matched skills.
 6. For Probe or Swarm, workers inspect read-only and return modification nodes. Lock stays on the current agent.
 7. Call `propose-nodes`, `accept-nodes`, `snapshot-plan`, and `snapshot-verify` in order.
@@ -104,10 +104,24 @@ Caller-supplied full catalogs and local registry flags are forbidden. `serverRes
 - `run-status`, `chain-plan`, `chain-status`
 - `delivery-doc`, `validate-json`, `feedback`
 
-Trusted local operations: `capabilities`, `probe`, `reassess`, `budget-init`, `budget-read`, `budget-status`, `budget-extend`, `gate-issue`, `gate-verify`, and `guarded-write`. Invoke them as `cli-aimlock local <operation> <repositoryRoot>` with JSON stdin and call local `capabilities` first for every input Schema.
+Trusted local operations: `capabilities`, `probe`, `reassess`, `budget-init`, `budget-read`, `budget-status`, `budget-extend`, `budget-auto-renew-request`, `budget-auto-renew`, `budget-auto-renew-stop`, `gate-issue`, `gate-verify`, and `guarded-write`. Invoke them as `cli-aimlock local <operation> <repositoryRoot>` with JSON stdin and call local `capabilities` first for every input Schema.
 
 `chain-plan` accepts only server-resolved skill IDs. High-risk work is blocked unless both Confirm Protocol and Validator were resolved. Confirm Protocol is forced to the first step; the caller must invoke the returned `confirmProtocolRequest`, then submit its authoritative `interaction-answer` response with the same `confirmationRequestId`. Replayed or mismatched approval remains blocked. When `swarm` is present, the plan inserts the internal `coordinator.conflict-scan` step immediately before it; no unrelated external skill is added.
 
+## Long-task read-time renewal
+
+Swarm starts with 60 minutes; Lock and Probe remain 2 and 8 minutes. Time is wall-clock elapsed since budget initialization, including waits. Renewal is evaluated on a budgeted source/cache read, never by `budget-status` or a background timer.
+
+An expired but still authorized budget reports `autoRenewEligible: true`, `decisionRequired: false`, and `nextActions: ["budget-read"]`; continue through that read operation to apply the permitted time extension. A status query never consumes an interval.
+
+1. Call `budget-auto-renew-request` with `chainId`, a unique `requestId`, `scope: {goal, allowedPaths}`, and `policy: {intervalMs, maxRenewals}`. Use literal repository-relative files/directories from the accepted task scope. The returned Confirm interaction states the exact task, scope, interval and total renewal cap.
+2. Render that interaction to the user once and obtain an authoritative Confirm Protocol `interaction-answer` response. Invoke `budget-auto-renew` with the same chain/scope/policy and that `confirmation`. A generic earlier approval, remembered response, altered scope or replay does not authorize renewal.
+3. Expired reads within that scope automatically consume the required fixed intervals up to the approved `maxRenewals`. Each interval records its reason, timestamp, count and cumulative duration. File/token limits and write permissions do not increase; exhausted quotas or renewal caps still explicitly block. Missed wall-clock intervals count toward the cap.
+4. Call `budget-auto-renew-stop` with `reason: "revoked"` when the user revokes renewal, and `reason: "completed"` when the task finishes. Completion prohibits further reads. The local persistent chain executor also closes an existing budget when execution succeeds. Other IDE hosts must send the completion signal; this package cannot observe unrelated IDE completion automatically.
+5. The authorization is immutable for that chain. Revocation never creates a new allowance; a later expansion requires a separate exact `budget-extend` approval, and a new task must use its own chain. Never infer permission from a long-running task or from authorization to implement this feature.
+
+Example request input: `{"chainId":"task-42","requestId":"renew-task-42","scope":{"goal":"Complete the approved refactor","allowedPaths":["src/module"]},"policy":{"intervalMs":3600000,"maxRenewals":8}}`.
+
 ## Interrupt and keep-alive
 
 Call `interrupt` before acting on an interruption:
@@ -132,7 +146,7 @@ Aimlock returns the protocol; it does not start a timer.
 | A3 | 官方技能按需路由 | 已实现 | 服务端读取当前已发布官方目录，只注入与需求匹配的技能；不加载完整目录。 |
 | A4 | 快照写入门禁 | 已实现（需宿主路由） | 本地运行器重读真实文件副本并签发 Ed25519 短期凭证；凭证绑定 chainId、快照摘要和路径。只有经过 `guarded-write` 的写入能被物理拦截，IDE 宿主必须关闭旁路批量写入口。 |
 | A5 | 真实分档与逐级升级 | 已实现 | 本地读取真实路径、Git 历史、包边界和 import 图；可从新鲜 ContextBase 地图解析精确目标符号；调用方自报复杂度不能覆盖探测，升级继承现有证据。 |
-| A6 | 读取预算与截止 | 已实现（需宿主路由） | Lock/Probe/Swarm 限制 3/10/30 文件与 2/8/15 分钟；Probe/Swarm 另限 30K/100K 估算 token，并用进程间锁阻止并发超额。 |
+| A6 | 读取预算与截止 | 已实现（需宿主路由） | Lock/Probe/Swarm 限制 3/10/30 文件与 2/8/60 分钟；Probe/Swarm 另限 30K/100K 估算 token，并用进程间锁阻止并发超额。 |
 | A7 | AutoCoord 物理联锁 | 已实现（需宿主路由） | `gate-issue` 显式选择是否需要协调；协调凭证绑定 Swarm 签名文件租约，`guarded-write` 在同一临界区校验凭证、活动锁和路径范围。活动依赖等待会阻断预算读取。 |
 | A8 | 高风险确认联锁 | 已实现（需宿主调用） | 高风险需求自动路由 Confirm Protocol；`chain-plan` 在权威 `interaction-answer` 返回前保持阻断，并校验请求 ID、审计与回调绑定。 |
 
@@ -165,3 +179,12 @@ Aimlock returns the protocol; it does not start a timer.
 ## 宿主持久执行
 
 使用 [chain-executor.md](references/chain-executor.md) 的显式 `chain init/resume/status/answer` 协议驱动本地持久步骤。`run` 的需求采集、远端 `nextStep` 与 `completed` 均不等于已执行。只有真实 broker/协调器/命令结果及绑定证据能推进；未答复人工裁决禁止恢复，发送后结果不确定禁止自动重发。CLI 终端不提供 OS 隔离或独立可信 runner。
+
+## 服务端沙箱规划与 IDE 执行
+
+1. 用户在模型设置中启用自己的模型地址、API Key 和模型名后，规划优先使用该配置；未启用个人模型时使用官方模型并执行有限套餐额度。个人模型失败必须明确报错，禁止自动切换模型或消耗官方额度。
+2. 准备请求 JSON，明确 requestId、目标、允许文件、最大修改行数和批准的检查命令；运行 `npx cli-aimlock@latest brain plan <repositoryRoot> <request.json>`。服务端调用模型规划，再由隔离沙箱编译结构化计划；保留返回的 request/response 交接包。
+3. 审查返回计划的允许范围、基线哈希和检查命令；完成现有 Aimlock 范围、快照和写入门禁后，由 IDE 修改代码。计划本身不授权扩大范围，不替代写入门禁。
+4. 运行 `npx cli-aimlock@latest brain check <repositoryRoot> <handoff.json>` 执行批准的检查并回传产物哈希和结果。普通 IDE 回传属于 client-reported，不能据此声称可信验证通过。
+5. 只有已批准的可信 runner 生成与本次计划和报告绑定的签名收据后，才运行 `npx cli-aimlock@latest brain validate <repositoryRoot> <validation.json>`。没有可信收据时保持已回传状态，不伪造验证。
+6. 请求发送后结果不确定时，先用 `brain status <repositoryRoot> <status.json>` 按 requestId 或 planId 查询；禁止自动重发规划或重复计费。

package/skill/skill.json

@@ -6,5 +6,5 @@
   "name": "aimlock",
   "schemaVersion": "aimlock.skill.request/1.1",
   "type": "Skill",
-  "version": "v7.0.34"
+  "version": "v7.0.36"
 }