cli-aimlock 7.0.37 → 7.0.38

package/aimlock-chain-executor.mjs

@@ -1,3 +1,4 @@
+import { decisionResumesTask, decisionTargetsTask } from 'cli-swarm/coordinator'
 import { randomUUID } from 'node:crypto'
 import { assertChainNotSuspended } from './aimlock-coordination.mjs'
 import { fail } from './aimlock-local-fs.mjs'
@@ -57,14 +58,13 @@ function finish(record, output, status) {
 
 async function stillWaiting(session, output, pending) {
   if (output.status === 'waiting') return true
-  const releasedByHuman = pending.decision?.status === 'resolved'
-    && pending.decision.answer === 'resume:' + pending.input.agentId
+  const releasedByHuman = pending.decision && decisionResumesTask(pending.decision, pending.input)
   if (output.status !== 'blocked' || (output.wakePackage?.reason !== 'event-received' && !releasedByHuman)) return false
   const current = (await callCoordinator(session, 'status', {})).state
   const task = current.tasks.find((item) => item.taskId === pending.input.taskId)
   if (!task || ['completed', 'failed', 'reclaimed'].includes(task.status)) return false
   return current.waits.some((wait) => wait.taskId === task.taskId && wait.status === 'active')
-    || current.decisions.some((decision) => decision.status === 'pending' && decision.agents.includes(task.agentId))
+    || current.decisions.some((decision) => decisionTargetsTask(decision, task) && decision.status === 'pending')
 }
 
 async function driveWait(session) {
@@ -80,8 +80,7 @@ async function driveWait(session) {
     await prepareHuman(session, output.confirmProtocolRequests[0].input.interaction, pending.input)
     return
   }
-  const releasedByHuman = pending.decision?.status === 'resolved'
-    && pending.decision.answer === 'resume:' + pending.input.agentId
+  const releasedByHuman = pending.decision && decisionResumesTask(pending.decision, pending.input)
     && output.status === 'resolved'
   if (releasedByHuman) {
     finish(session.record, { ...output, status: 'resolved-by-human',

package/aimlock-coordination.mjs

@@ -1,3 +1,4 @@
+import { decisionResumesTask, decisionTargetsTask } from 'cli-swarm/coordinator'
 import { verify } from 'node:crypto'
 import { lstat, readFile } from 'node:fs/promises'
 import { basename, resolve } from 'node:path'
@@ -35,9 +36,9 @@ function failureHandled(task, tasks, inspected = new Set()) {
 
 function parkedAfterDecision(task, tasks, decisions) {
   if (task.status !== 'blocked' || task.blockedReason !== 'human-decision') return false
-  const decision = decisions.findLast((item) => item.agents.includes(task.agentId))
+  const decision = decisions.findLast((item) => decisionTargetsTask(item, task))
   return decision?.status === 'resolved'
-    && tasks.some((active) => active.status === 'active' && decision.answer === 'resume:' + active.agentId)
+    && tasks.some((active) => active.status === 'active' && decisionResumesTask(decision, active))
 }
 
 function assertChainRunnable(state, chainId) {
@@ -46,7 +47,7 @@ function assertChainRunnable(state, chainId) {
   const wait = state.waits.find((item) => item.chainId === chainId && item.status === 'active')
   if (wait) fail('AIMLOCK_COORDINATION_WAITING', 'chain ' + chainId + ' is suspended until ' + wait.event + ' or ' + wait.deadlineAt)
   const pending = state.decisions.some((decision) => decision.status === 'pending'
-    && tasks.some((task) => decision.agents.includes(task.agentId)))
+    && tasks.some((task) => decisionTargetsTask(decision, task)))
   const unresolved = tasks.some((task) => ['failed', 'reclaimed'].includes(task.status)
     && !failureHandled(task, tasks))
   if (!tasks.some((task) => task.status === 'active') || pending || unresolved

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.37";
+const COMPILER_VERSION = "v7.0.38";
 const KEEP_ALIVE_SECONDS = 90;
 const KEEP_ALIVE_MESSAGE = "智能目标持续执行中，请勿关闭！";
 const BYPASS_LINE_BUDGET = 500;

package/aimlock-tasks-cli.mjs

@@ -0,0 +1,202 @@
+import { stdin, stdout } from 'node:process'
+import { executeCoordinatorOperation } from 'cli-swarm/coordinator'
+import { errorRecord } from './aimlock-chain-model.mjs'
+import { fail } from './aimlock-local-fs.mjs'
+
+const TASK_INPUT_MAX_BYTES = 1_048_576
+const MAX_TASK_DELIVERY_TIMEOUT_MS = 2_147_483_647
+export const TASK_DELIVERY_TIMEOUT_MS = 30_000
+export const TASK_OPERATIONS = Object.freeze([
+  'task-describe', 'task-checkpoint', 'task-resume', 'message-route', 'message-status',
+  'message-accept', 'message-complete', 'message-delivery-start', 'message-delivery-report',
+  'message-resolve', 'handoff-release', 'handoff-resume',
+])
+export const TASKS_USAGE = [
+  '  cli-aimlock tasks <operation> <repositoryRoot> < task-message.json',
+  '  cli-aimlock tasks capabilities <repositoryRoot>',
+  `      Operations: ${TASK_OPERATIONS.join(', ')}.`,
+  '      Message routing preserves the original plan. A resume package does not execute work.',
+].join('\n')
+
+function taskCapabilities(capabilities) {
+  if (!capabilities || !Array.isArray(capabilities.operations)
+    || !capabilities.operationSchemas || typeof capabilities.operationSchemas !== 'object') {
+    fail('AIMLOCK_TASKS_CAPABILITIES_INVALID', 'coordinator task capabilities are invalid')
+  }
+  for (const operation of TASK_OPERATIONS) {
+    if (!capabilities.operations.includes(operation) || !Object.hasOwn(capabilities.operationSchemas, operation)) {
+      fail('AIMLOCK_TASKS_OPERATION_UNAVAILABLE', `coordinator task operation is unavailable: ${operation}`)
+    }
+  }
+  return { operations: [...TASK_OPERATIONS], operationSchemas: Object.fromEntries(
+    TASK_OPERATIONS.map((operation) => [operation, capabilities.operationSchemas[operation]]),
+  ) }
+}
+
+async function readTaskInput(input) {
+  const chunks = []
+  let byteLength = 0
+  for await (const chunk of input) {
+    if (typeof chunk !== 'string' && !(chunk instanceof Uint8Array)) {
+      fail('AIMLOCK_TASKS_INPUT_INVALID', 'task input must be UTF-8 JSON')
+    }
+    const bytes = Buffer.from(chunk)
+    byteLength += bytes.byteLength
+    if (byteLength > TASK_INPUT_MAX_BYTES) fail('AIMLOCK_TASKS_INPUT_TOO_LARGE', 'task input exceeds 1 MiB')
+    chunks.push(bytes)
+  }
+  if (byteLength === 0) fail('AIMLOCK_TASKS_INPUT_REQUIRED', 'task input is required on stdin')
+  let value
+  try { value = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(chunks))) }
+  catch { fail('AIMLOCK_TASKS_INPUT_INVALID', 'task input must be valid UTF-8 JSON') }
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    fail('AIMLOCK_TASKS_INPUT_INVALID', 'task input must be a JSON object')
+  }
+  return value
+}
+
+export async function dispatchTasks(args, dependencies = {}) {
+  const [operation, repositoryRoot] = args
+  if (args.length !== 2 || (operation !== 'capabilities' && !TASK_OPERATIONS.includes(operation))) {
+    fail('AIMLOCK_TASKS_USAGE_INVALID', TASKS_USAGE)
+  }
+  const execute = dependencies.executeCoordinatorOperation ?? executeCoordinatorOperation
+  const input = dependencies.input ?? stdin
+  if (operation === 'capabilities') return taskCapabilities(await execute(operation, repositoryRoot, {}))
+  return execute(operation, repositoryRoot, await readTaskInput(input))
+}
+
+export async function runTasksCli(args) {
+  try {
+    const result = await dispatchTasks(args)
+    stdout.write(JSON.stringify(result) + '\n')
+    if (result.status === 'blocked' || result.status === 'waiting') process.exitCode = 2
+    else if (result.status === 'failed' || result.status === 'uncertain') process.exitCode = 1
+  } catch (error) {
+    stdout.write(JSON.stringify({ status: 'failed', error: errorRecord(error) }) + '\n')
+    process.exitCode = 1
+  }
+}
+
+function sourceIdentity(input) {
+  const identity = {}
+  for (const field of ['taskId', 'agentId', 'chainId']) {
+    if (typeof input?.[field] !== 'string' || !input[field].trim()) {
+      fail('AIMLOCK_TASKS_IDENTITY_REQUIRED', `task identity requires ${field}`)
+    }
+    identity[field] = input[field]
+  }
+  return identity
+}
+
+function receiptMatches(receipt, delivery) {
+  return receipt && typeof receipt === 'object'
+    && receipt.requestId === delivery.requestId && receipt.targetTaskId === delivery.targetTaskId
+    && typeof receipt.receiptId === 'string' && receipt.receiptId.length > 0
+}
+
+async function deliveryStatus(execute, root, source, delivery) {
+  const status = await execute('message-status', root, { ...source, requestId: delivery.requestId })
+  if (!status || !Object.hasOwn(status, 'receipt')) {
+    fail('AIMLOCK_TASKS_RECEIPT_INVALID', 'coordinator message status has no receipt field')
+  }
+  if (status.receipt !== null && !receiptMatches(status.receipt, delivery)) {
+    fail('AIMLOCK_TASKS_RECEIPT_INVALID', 'coordinator receipt does not match the target delivery')
+  }
+  return status.receipt
+}
+
+async function awaitHostDelivery(adapter, delivery, timeoutMs) {
+  let timer
+  const deadline = new Promise((_resolve, reject) => {
+    timer = setTimeout(() => reject(Object.assign(new Error(
+      `host delivery timed out after ${timeoutMs} ms; the actual delivery was not canceled`,
+    ), { code: 'AIMLOCK_TASKS_DELIVERY_TIMEOUT' })), timeoutMs)
+  })
+  try {
+    return await Promise.race([Promise.resolve().then(() => adapter.deliver(delivery)), deadline])
+  } finally { clearTimeout(timer) }
+}
+
+async function deliverTaskMessage(root, source, delivery, adapter, execute, timeoutMs) {
+  const recorded = await deliveryStatus(execute, root, source, delivery)
+  if (recorded) return { requestId: delivery.requestId, status: 'accepted', receipt: recorded, recovered: true }
+  const claim = await execute('message-delivery-start', root, { ...source, requestId: delivery.requestId })
+  if (!claim || typeof claim.claimed !== 'boolean'
+    || (claim.claimed && (typeof claim.attemptId !== 'string' || !claim.attemptId))) {
+    fail('AIMLOCK_TASKS_DELIVERY_CLAIM_INVALID', 'coordinator delivery claim is invalid')
+  }
+  if (!claim.claimed) {
+    const receipt = await deliveryStatus(execute, root, source, delivery)
+    if (receipt) return { requestId: delivery.requestId, status: 'accepted', receipt, recovered: true }
+    fail('AIMLOCK_TASKS_DELIVERY_UNCERTAIN', 'delivery was already attempted; query its receipt before any further action')
+  }
+  let delivered
+  let deliveryError
+  try { delivered = await awaitHostDelivery(adapter, { ...delivery, attemptId: claim.attemptId }, timeoutMs) }
+  catch (error) { deliveryError = errorRecord(error) }
+  const receipt = await deliveryStatus(execute, root, source, delivery)
+  if (!receipt) {
+    const detail = deliveryError ? `: ${deliveryError.message}` : ''
+    fail('AIMLOCK_TASKS_DELIVERY_UNCERTAIN', `target acceptance has not been recorded${detail}`)
+  }
+  if (!deliveryError && (!receiptMatches(delivered, delivery) || delivered.status !== 'accepted'
+    || delivered.receiptId !== receipt.receiptId)) {
+    fail('AIMLOCK_TASKS_RECEIPT_INVALID', 'adapter receipt does not match the recorded target acceptance')
+  }
+  return { requestId: delivery.requestId, status: 'accepted', receipt, recovered: Boolean(deliveryError),
+    ...(deliveryError ? { deliveryError } : {}) }
+}
+
+async function reportDeliveryFailure(root, source, delivery, error, execute, failures) {
+  const failure = errorRecord(error)
+  failures.push({ requestId: delivery.requestId, stage: 'delivery', error: failure })
+  try {
+    await execute('message-delivery-report', root, { ...source, requestId: delivery.requestId,
+      errorCode: typeof failure.code === 'string' ? failure.code : 'AIMLOCK_TASKS_DELIVERY_FAILED',
+      errorMessage: failure.message })
+  } catch (reportError) {
+    failures.push({ requestId: delivery.requestId, stage: 'delivery-report', error: errorRecord(reportError) })
+  }
+}
+
+/** A host adapter delivers messages; only the coordinator may issue durable acceptance receipts. */
+export async function handleTaskMessage(root, input, adapter, { deliveryTimeoutMs = TASK_DELIVERY_TIMEOUT_MS } = {}) {
+  if (!adapter || typeof adapter.deliver !== 'function' || typeof adapter.continueTask !== 'function') {
+    fail('AIMLOCK_TASKS_ADAPTER_REQUIRED', 'host adapter requires deliver and continueTask functions')
+  }
+  if (!Number.isSafeInteger(deliveryTimeoutMs) || deliveryTimeoutMs <= 0
+    || deliveryTimeoutMs > MAX_TASK_DELIVERY_TIMEOUT_MS) {
+    fail('AIMLOCK_TASKS_TIMEOUT_INVALID', 'deliveryTimeoutMs must be a positive integer within the timer limit')
+  }
+  const source = sourceIdentity(input)
+  const execute = executeCoordinatorOperation
+  const routed = await execute('message-route', root, input)
+  if (!routed || !Array.isArray(routed.deliveries)
+    || Object.keys(source).some((field) => routed.source?.[field] !== source[field])) {
+    fail('AIMLOCK_TASKS_ROUTE_INVALID', 'coordinator message route does not match the source task')
+  }
+  const deliveries = []
+  const failures = []
+  for (const delivery of routed.deliveries) {
+    if (delivery.status !== 'pending-delivery') continue
+    try { deliveries.push(await deliverTaskMessage(root, source, delivery, adapter, execute, deliveryTimeoutMs)) }
+    catch (error) { await reportDeliveryFailure(root, source, delivery, error, execute, failures) }
+  }
+  let continuation = null
+  let continuationDispatched = false
+  try {
+    continuation = await execute('task-resume', root, source)
+    if (!continuation || typeof continuation.canContinue !== 'boolean'
+      || Object.keys(source).some((field) => continuation[field] !== source[field])) {
+      fail('AIMLOCK_TASKS_RESUME_INVALID', 'coordinator resume package does not match the original task')
+    }
+    if (continuation.canContinue) {
+      await adapter.continueTask(continuation)
+      continuationDispatched = true
+    }
+  } catch (error) { failures.push({ requestId: null, stage: 'continuation', error: errorRecord(error) }) }
+  return { status: failures.length ? 'failed' : continuationDispatched ? 'continued' : 'waiting',
+    messageId: routed.messageId, requests: routed.requests, deliveries, continuation,
+    continuationDispatched, failures }
+}

package/cli.mjs

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { TASKS_USAGE, runTasksCli } from './aimlock-tasks-cli.mjs'
 import { realpathSync } from 'node:fs'
 import { dirname, resolve } from 'node:path'
 import { cwd, stdin, stdout } from 'node:process'
@@ -95,7 +96,7 @@ export function localAimlockApplicability(facts) {
 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
+  return usage.replace(COMMON_RUN_USAGE, AIMLOCK_RUN_USAGE) + '\n\n' + CHAIN_USAGE + '\n\n' + TASKS_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.'
 }
@@ -196,6 +197,8 @@ const cliPath = fileURLToPath(import.meta.url)
 if (process.argv[1] && realpathSync(resolve(process.argv[1])) === cliPath) {
   if (process.argv[2] === 'brain') {
     await runBrainCli(process.argv.slice(3))
+  } else if (process.argv[2] === 'tasks') {
+    await runTasksCli(process.argv.slice(3))
   } else if (process.argv[2] === 'chain') {
     await runChainCli(process.argv.slice(3))
   } else if (process.argv[2] === 'local') {

package/package.json

@@ -3,7 +3,7 @@
     "cli-aimlock": "./cli.mjs"
   },
   "dependencies": {
-    "cli-swarm": "7.0.37"
+    "cli-swarm": "7.0.38"
   },
   "description": "Aimlock skill installer for CLI.Tax: lock a user request into an executable aim and route Blueprint, Swarm, and Calctool.",
   "exports": {
@@ -11,7 +11,8 @@
     "./local-runner": "./aimlock-local-runner.mjs",
     "./runtime": "./aimlock-runtime.mjs",
     "./chain-executor": "./aimlock-chain-executor.mjs",
-    "./brain-client": "./brain-client.mjs"
+    "./brain-client": "./brain-client.mjs",
+    "./tasks": "./aimlock-tasks-cli.mjs"
   },
   "files": [
     "cli.mjs",
@@ -31,6 +32,7 @@
     "aimlock-chain-human.mjs",
     "aimlock-chain-executor.mjs",
     "aimlock-chain-cli.mjs",
+    "aimlock-tasks-cli.mjs",
     "aimlock-chain-outcomes.mjs",
     "aimlock-context-map.mjs",
     "aimlock-coordination.mjs",
@@ -44,7 +46,8 @@
     "aimlock-runtime.mjs",
     "brain-client.mjs",
     "brain-client-files.mjs",
-    "skill/references/chain-executor.md"
+    "skill/references/chain-executor.md",
+    "skill/references/task-routing.md"
   ],
   "license": "UNLICENSED",
   "name": "cli-aimlock",
@@ -53,5 +56,5 @@
     "url": "https://github.com/88208555/aimlock-clitax.git"
   },
   "type": "module",
-  "version": "7.0.37"
+  "version": "7.0.38"
 }

package/skill/SKILL.md

@@ -5,7 +5,7 @@ description: "Aimlock 仅用于大型、深度、跨模块、高风险、需要
 
 # Aimlock Skill
 
-Package version: v7.0.37
+Package version: v7.0.38
 
 Endpoint: https://cli.tax/R3mQ8kWpXn
 
@@ -129,7 +129,7 @@ Call `interrupt` before acting on an interruption:
 - forced stop → `stop`;
 - status query → `status`;
 - related addition → `fuse`;
-- unrelated request → `spawn`.
+- unrelated request → first query existing task ownership through `tasks message-route`; reuse its owner when resolved. Unresolved work remains a recorded pending request. Legacy `spawn` is a recommendation only and must not replace the current goal or create an unauthorized conversation.
 
 For an active incomplete goal, the caller sends exactly every 90 seconds:
 
@@ -194,3 +194,13 @@ Aimlock returns the protocol; it does not start a timer.
 仅在 TLS 握手前确定尚未发送 HTTP 请求时，broker 才允许最多 3 次连接尝试，并受总超时约束。请求发出后发生断线或响应中断，只用 GET 查询原 requestId 的服务端回执，禁止重发 POST；未取得有效回执时保留不确定状态，不得假定成功或继续依赖步骤。
 
 `npx cli-aimlock@latest recover <operation> <requestId>` 可重新查询原调用，不会重做操作或重复计费。链恢复不会跳过人工确认，也不会自动重跑结果不确定的本地命令。代理连接需 Node.js 22.21+ 或 24.5+；不支持的运行时会明确报错。
+
+## 新消息归属与原任务连续性
+
+多任务协作时先登记任务目标、原始验收项和宿主定位；每条用户新需求在执行前使用 [task-routing.md](references/task-routing.md) 的 `task-describe → message-route → message-accept → task-resume` 协议。先查已有任务归属，再决定当前任务补充、转交、歧义暂存或显式接手。同一条消息的独立需求分别路由，不能用新消息覆盖原目标。
+
+转交只是消息状态，不等于原任务完成。接收方按 requestId 去重，只有持久接收回执才算接手；来源任务继续不依赖该交接的工作。退出、上下文压缩或宿主重启后，必须先读取 `task-resume` 恢复原目标、检查点、未完成项与待投递请求。
+
+用户明确要求在当前任务处理时，保留原目标；已由其他任务负责的范围需 `handoff-release` 完成安全交接，再重新验证 Aimlock 范围、快照与写入权限。禁止把别人的签名租约、预算或通过证据当作当前任务的新授权。归属不明只暂存新需求，不暂停原任务。
+
+这些操作使用同一协调根目录的持久台账。宿主必须在新消息入口调用并消费结果；技能不能拦截未接入的 IDE，也不会自动创建会话、Git 分支、常驻服务或跨机器复制私密消息。

package/skill/references/task-routing.md

@@ -0,0 +1,13 @@
+# Aimlock task message entry
+
+Use `cli-aimlock tasks capabilities <coordinationRoot>` to discover the task registration, routing, acknowledgement, handoff and resume schemas. JSON inputs use stdin. This entry calls the installed `cli-swarm/coordinator` directly and preserves its persistent ledger.
+
+Before executing each new user requirement, restore the original task with `task-resume`, classify distinct items and call `message-route`. Reuse an existing owner when identified. Preserve uncertain requests and the current task's unfinished requirements. Do not append new user messages as replacement execution plans or overwrite chain state.
+
+The installed Swarm reference `references/task-routing.md` defines the shared protocol, matching evidence, receipt validation and handoff lifecycle. Do not duplicate or maintain a separate routing algorithm in Aimlock.
+
+The `cli-aimlock/tasks` export provides `handleTaskMessage(root,input,adapter,options)`. The IDE supplies an authorized destination-aware `deliver` function and `continueTask`. Each delivery must return the destination's persisted acceptance receipt. Atomic delivery claims prevent blind retries after process interruption. The helper checks authoritative message status and reports explicit failures; only a runnable source task continues. Delivery is bounded to 30 seconds unless the host sets a positive `options.deliveryTimeoutMs`. Timeouts preserve uncertain delivery without claiming it was cancelled; a runnable original task still continues.
+
+Explicit forced assignment must preserve the current task checkpoint. Complete `handoff-release` at the previous owner's safe boundary, then obtain a fresh Aimlock contract/snapshot/pass for the receiving scope. After completion, the previous owner uses `handoff-resume` to refresh actual file fingerprints before rebuilding its own snapshot and continuing. Credentials, budgets and previous test receipts are never transferred as new authorization.
+
+Status questions and explicit stop/cancel retain their existing host behavior. New requirements alone never cancel an unfinished goal. Each host must call this entry at its message boundary and consume pending inboxes after restart. The package cannot intercept unrelated hosts, create tasks or Git branches, install a background service, or grant access to unrelated accounts.

package/skill/skill.json

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