cli-aimlock 1.0.1

package/README.md

@@ -0,0 +1,10 @@
+# cli-aimlock
+
+Aimlock — 智能目标 skill（CLI.Tax 发布）。
+
+- 把需求锁成可执行目标，阻止思考漂移、执行漂移、范围膨胀
+- Lock / Probe / Swarm 三档：小改不调蜂群；大改才派单
+- 改前文件快照，禁止创建 git 分支
+- 按目标调用 Blueprint、Swarm、Calctool；需要出图时调用 Image，让智能体生成图片
+
+安装：`npx cli-aimlock@latest install`

package/cli.mjs

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+import { copyFile, mkdir, writeFile } from 'node:fs/promises'
+import { createInterface } from 'node:readline/promises'
+import { stdin, stdout } from 'node:process'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { existsSync, readFileSync } from 'node:fs'
+
+const ENDPOINT = 'https://cli.tax/R3mQ8kWpXn'
+const SCHEMA_VERSION = 'aimlock.skill.request/1.0'
+const PACKAGE_SKILL_DIR = join(dirname(fileURLToPath(import.meta.url)), 'skill')
+const INSTALL_META = 'install-meta.json'
+const LATEST_ENDPOINT = 'https://cli.tax/api/public/skills/R3mQ8kWpXn'
+
+const INTAKE_QUESTIONS = [
+  { id: 'goal', required: true, prompt: 'What must be true when this finishes, and what must never change?', example: '只改税率常量一行，不改其它计税逻辑' },
+  { id: 'targetFiles', required: true, prompt: 'Which file paths are in scope? Use unknown if not located yet.', example: 'apps/web/src/tax.ts' },
+  { id: 'estimatedChangedLines', required: true, prompt: 'How many lines should change?', example: '1' },
+  { id: 'crossModule', required: true, prompt: 'Does this cross modules? yes or no.', example: 'no' },
+  { id: 'needParallel', required: true, prompt: 'Must independent modules run in parallel? yes or no.', example: 'no' },
+  { id: 'goalKind', required: true, prompt: 'Goal kind: code, calculator, image, mixed, or docs.', example: 'code' },
+  { id: 'deliveryDoc', required: true, prompt: 'After success, summarize a local delivery document? yes or no.', example: 'no' },
+]
+
+function usage() {
+  return [
+    'cli-aimlock — install and run the Aimlock skill from CLI.Tax',
+    '',
+    'Usage:',
+    '  npx cli-aimlock@latest install [directory]',
+    '      Install Aimlock for the current IDE (Codex skills directory by default).',
+    '  npx cli-aimlock@latest check [directory]',
+    '      Check whether the installed skill has a newer version on cli.tax.',
+    '  npx cli-aimlock@latest run',
+    '      Handshake: capabilities, intake questions, save AIMLOCK-REQUIREMENTS.json.',
+    '',
+    `Endpoint: ${ENDPOINT}`,
+  ].join('\n')
+}
+
+function readMeta(dir) {
+  const path = join(dir, INSTALL_META)
+  if (!existsSync(path)) return null
+  try { return JSON.parse(readFileSync(path, 'utf8')) } catch { return null }
+}
+
+async function fetchLatestVersion() {
+  try {
+    const response = await fetch(LATEST_ENDPOINT)
+    if (!response.ok) return null
+    const data = await response.json()
+    return { version: data.version ?? '', displayName: data.displayName ?? 'aimlock' }
+  } catch {
+    return null
+  }
+}
+
+async function postRequest(operation, requestId) {
+  const response = await fetch(ENDPOINT, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      input: { schemaVersion: SCHEMA_VERSION, requestId, operation, input: {} },
+    }),
+  })
+  let payload
+  try {
+    payload = await response.json()
+  } catch {
+    throw new Error(`aimlock ${operation} failed: non-JSON response (HTTP ${response.status}). Check ${ENDPOINT}.`)
+  }
+  if (!response.ok || payload?.ok !== true) {
+    const message = payload?.error?.message ?? payload?.error ?? `HTTP ${response.status}`
+    throw new Error(`aimlock ${operation} failed: ${message}`)
+  }
+  return payload
+}
+
+function installTarget(explicit) {
+  if (explicit) return resolve(explicit)
+  const codexHome = process.env.CODEX_HOME?.trim()
+  if (codexHome) return join(codexHome, 'skills', 'aimlock')
+  return join(process.cwd(), '.codex', 'skills', 'aimlock')
+}
+
+async function install(explicit) {
+  const target = installTarget(explicit)
+  await mkdir(target, { recursive: true })
+  const previous = readMeta(target)
+  await copyFile(join(PACKAGE_SKILL_DIR, 'SKILL.md'), join(target, 'SKILL.md'))
+  await copyFile(join(PACKAGE_SKILL_DIR, 'skill.json'), join(target, 'skill.json'))
+  const latest = await fetchLatestVersion()
+  await writeFile(join(target, INSTALL_META), `${JSON.stringify({
+    source: 'R3mQ8kWpXn',
+    slug: 'aimlock',
+    version: latest?.version ?? '',
+    endpoint: ENDPOINT,
+    installedAt: new Date().toISOString(),
+  }, null, 2)}\n`)
+  if (previous?.version && latest?.version && previous.version !== latest.version) {
+    console.log(`aimlock skill updated: ${target}`)
+    console.log(`  ⤴ ${previous.version} → ${latest.version}`)
+  } else {
+    console.log(`aimlock skill installed: ${target}${latest?.version ? ` (${latest.version})` : ''}`)
+  }
+  if (latest?.version) console.log(`Latest version on cli.tax: ${latest.version}`)
+  console.log('Next: return to your IDE and describe the aim. Do not edit code until Aimlock classifies and gates mutate.')
+}
+
+async function check(explicit) {
+  const target = installTarget(explicit)
+  const local = readMeta(target)
+  const latest = await fetchLatestVersion()
+  if (!latest) {
+    console.log('aimlock: cannot reach cli.tax to check updates.')
+    process.exitCode = 1
+    return
+  }
+  if (!local?.version) {
+    console.log(`aimlock: no version record in ${target}. Latest on cli.tax: ${latest.version}.`)
+    process.exitCode = 1
+    return
+  }
+  if (local.version === latest.version) {
+    console.log(`aimlock is up to date (${latest.version}) at ${target}`)
+    return
+  }
+  console.log(`aimlock update available: ${local.version} → ${latest.version}`)
+  console.log('Run: npx cli-aimlock@latest install')
+  process.exitCode = 1
+}
+
+async function askOne(question, readline) {
+  const requiredMark = question.required ? ' (required)' : ''
+  console.log(`\n${question.prompt}${requiredMark}`)
+  console.log(`Example: ${question.example}`)
+  for (;;) {
+    const answer = (await readline.question('> ')).trim()
+    if (answer || !question.required) return answer || ''
+    console.log('This question is required. Please answer before continuing.')
+  }
+}
+
+async function run() {
+  const capabilities = await postRequest('capabilities', 'cli-1')
+  const skill = capabilities.output?.skill ?? {}
+  const notice = capabilities.output?.firstUseNotice?.zh
+  console.log(`aimlock ${skill.version ?? ''} — lock the aim, then fire`)
+  if (notice) console.log(notice)
+  const readline = createInterface({ input: stdin, output: stdout })
+  const answers = []
+  try {
+    for (const question of INTAKE_QUESTIONS) {
+      answers.push({ id: question.id, prompt: question.prompt, answer: await askOne(question, readline) })
+    }
+  } finally {
+    readline.close()
+  }
+  const target = join(process.cwd(), 'AIMLOCK-REQUIREMENTS.json')
+  await writeFile(target, `${JSON.stringify({
+    schemaVersion: SCHEMA_VERSION,
+    endpoint: ENDPOINT,
+    createdAt: new Date().toISOString(),
+    answers,
+  }, null, 2)}\n`)
+  console.log(`\nRequirements saved: ${target}`)
+  console.log('Next: continue in your IDE agent with this file. Do not mutate until classify + mutate-gate.')
+}
+
+const command = process.argv[2] ?? 'help'
+const argument = process.argv[3] ?? ''
+try {
+  if (command === 'install') await install(argument)
+  else if (command === 'check') await check(argument)
+  else if (command === 'run') await run()
+  else if (command === '--help' || command === '-h' || command === 'help') console.log(usage())
+  else {
+    console.error(`Unknown command: ${command}\n`)
+    console.log(usage())
+    process.exitCode = 1
+  }
+} catch (error) {
+  console.error(error instanceof Error ? error.message : error)
+  process.exitCode = 1
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "cli-aimlock",
+  "version": "1.0.1",
+  "description": "Aimlock skill installer for CLI.Tax: lock a user request into an executable aim and route Blueprint, Swarm, Calctool, and Image.",
+  "type": "module",
+  "bin": {
+    "cli-aimlock": "./cli.mjs"
+  },
+  "files": [
+    "cli.mjs",
+    "README.md",
+    "skill/SKILL.md",
+    "skill/skill.json"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "UNLICENSED",
+  "keywords": [
+    "cli.tax",
+    "skill",
+    "installer",
+    "agent"
+  ]
+}

package/skill/SKILL.md

@@ -0,0 +1,127 @@
+---
+name: aimlock
+description: "Aimlock 把用户需求锁成可执行的智能目标，阻止思考漂移、执行漂移和范围膨胀。主智能体先读本规范，禁止立刻改代码：先拆 JSON 任务，按范围合同分成 Lock / Probe / Swarm。Lock 档单文件小改由主脑快照后改写；Probe 档只读分析修改节点，确认后再写；Swarm 档才调用蜂群。Blueprint 编规划合同，Swarm 派单执行，Calctool 生成计算工具，Image 让智能体生成图片。改前文件快照，禁止创建 git 分支。插话先判关联再更新任务；强制停止立即停止。目标未完成交出控制权时每 90 秒发送「智能目标持续执行中，请勿关闭！」。交付文档需用户确认。调用前必须 capabilities，再按 nextStep 前进。Locks a user request into an executable aim to stop thought-drift, execution-drift, and scope blow-ups. Read this skill first; do not edit code yet. Split JSON tasks; classify Lock / Probe / Swarm. Blueprint for contracts, Swarm for dispatch, Calctool for calculators, Image so the agent can generate pictures. Snapshot files before mutate; never create git branches. Interrupt: correlate first. Keep-alive every 90s while the aim is open. Delivery docs only if the user confirms. Always call capabilities first. Фиксирует запрос в исполняемую цель, чтобы остановить дрейф мысли, дрейф исполнения и раздувание объёма. Сначала эта спецификация, код не трогать. JSON-задачи, режимы Lock / Probe / Swarm. Blueprint — контракт, Swarm — раздача, Calctool — калькулятор, Image — генерация картинок агентом. Снимок файлов до правки, без git-веток. Сначала capabilities."
+---
+
+# Aimlock Skill
+
+Endpoint: https://cli.tax/R3mQ8kWpXn
+Request schema: aimlock.skill.request/1.0
+Response schema: aimlock.skill.response/1.0
+
+Aimlock is a policy layer. It does not replace Blueprint, Swarm, or Calctool. Image is a **capability** the agent uses to generate pictures, not a product line. Aimlock decides **when to fire, how wide, and how to stop drift**.
+
+## Request envelope
+
+POST JSON to the endpoint with an `input` wrapper:
+
+```json
+{
+  "input": {
+    "schemaVersion": "aimlock.skill.request/1.0",
+    "requestId": "<unique-id>",
+    "operation": "<operation>",
+    "input": {}
+  }
+}
+```
+
+## Operations
+
+- `capabilities`: modes, sibling skills, keep-alive text, first-use notice.
+- `help`: operation catalog.
+- `intake`: questions the IDE must ask before classify. One at a time.
+- `classify`: choose `lock` | `probe` | `swarm` from explicit facts. Missing facts → `blocked`.
+- `scope-contract`: allowed paths, forbidden paths, max changed lines, new-file / delete flags.
+- `skill-route`: whether to call Blueprint, Swarm, Calctool; call Image only so the agent can generate pictures.
+- `propose-nodes`: validate read-only modification nodes against the contract.
+- `accept-nodes`: auto-accept in-scope nodes; escalate worker conflicts.
+- `snapshot-plan`: file-copy snapshot. Git branches and worktrees are forbidden.
+- `mutate-gate`: mutate only after accept + snapshot.
+- `continuity-check`: traffic-light budget, tests, omission scan.
+- `interrupt`: `status` | `fuse` | `spawn` | `stop`.
+- `keep-alive`: arm a 90s ping while the goal is open.
+- `delivery-doc`: write a summary only if the user confirmed.
+- `validate-json`: validate an Aimlock run JSON.
+
+## Required flow
+
+1. Call `capabilities`. On first use in the conversation, show `firstUseNotice` once.
+2. Call `intake` and ask every **required** question one at a time. Do not mutate files.
+3. Call `classify` with the answers. Do not invent file lists or line budgets.
+4. Call `scope-contract`. Empty `allowedPaths` is `blocked`.
+5. Call `skill-route` with `mode`, `goalKind`, `hasBlueprint`.
+6. **Probe / Swarm:** workers read code only and return nodes. Call `propose-nodes` then `accept-nodes`.
+7. **Lock:** the main agent still snapshots, then mutates inside the contract. No swarm.
+8. Call `snapshot-plan`. Copy files into `snapshotRoot`. Never `git branch` / `git checkout -b` / worktree.
+9. Call `mutate-gate`. If `blocked`, do not write.
+10. After writes, call `continuity-check`. Red or yellow → roll back from the snapshot.
+11. Before yielding while the aim is open, call `keep-alive` with `goalComplete: false` and send the returned message.
+12. Reclaim temporary agents after green. Ask about `delivery-doc` only if intake said the user wants it.
+
+### Classify rules (deterministic)
+
+Facts required: `goal`, `targetFiles` (string array), `estimatedChangedLines`, `crossModule`, `needParallel`.
+
+- **lock**: exactly one file, ≤ 20 lines, not cross-module, not parallel.
+- **probe**: ≤ 3 files, ≤ 80 lines, not parallel.
+- **swarm**: otherwise.
+
+### Skill routing
+
+Default allowlist is **official skills**. `capabilities` (platform) returns `officialCatalog`. Pass it into `skill-route` with `mode`, `goalKind`, `hasBlueprint`.
+
+Call a hop only when `call` is true. That means the hop's capability matches this demand and the current chain allows it.
+
+- Do not call chain-unrelated skills.
+- Do not call self-extended or marketplace extras.
+- Extra skills enter the candidate list only when the user names them (`userSpecifiedSkills`). Then call that skill's `capabilities` and invoke only if its capability matches the demand.
+
+Do not call Image for ordinary code edits. Do not call Calctool unless the aim is a calculator tool.
+
+### Interrupt
+
+Call `interrupt` with `forceStop`, `isStatusQuery`, `related` as booleans. Do not execute a new request first.
+
+- `stop`: user forced stop.
+- `status`: report only.
+- `fuse`: related; signal the running agent; update JSON; continue.
+- `spawn`: unrelated; new temporary agent; do not hijack the current aim.
+
+### Keep-alive
+
+When the aim is incomplete and the IDE is about to yield, send exactly:
+
+`智能目标持续执行中，请勿关闭！`
+
+Interval: 90 seconds. Do not ping every 10 seconds. When `goalComplete` is true, do not arm.
+
+## Safety rules
+
+- Never create a git branch. Isolation is a file-copy snapshot plus a temporary agent context.
+- Never mutate before `mutate-gate` returns `allowed: true`.
+- Never treat missing files, timeouts, or 4xx/5xx as empty success. `blocked` and `failed` are errors.
+- Never send credentials in the envelope.
+- The response `status` must be `succeeded`; `blocked` and `failed` are not results.
+- Do not expand 1 line into 100. Over-budget is red; roll back.
+- Delivery documents are optional. Skip unless the user confirmed.
+
+## Examples
+
+### Lock: one-line constant
+
+User: 只改税率常量一行.
+
+`classify` → `lock`. Snapshot that file. Change the one line. `continuity-check` must stay within `maxChangedLines`.
+
+### Probe then mutate
+
+User: 修支付回调的状态机，可能有上下游.
+
+`classify` → `probe`. Worker returns nodes. If a node points outside `allowedPaths`, `propose-nodes` is `blocked`. After accept + snapshot, mutate.
+
+### Image capability
+
+User: 根据这个商品说明生成三张主图.
+
+`goalKind`: `image`. `skill-route` returns Image with `call: true`. The agent uses the Image skill to generate pictures. Aimlock still owns the aim, keep-alive, and interrupt rules.

package/skill/skill.json

@@ -0,0 +1,10 @@
+{
+  "name": "aimlock",
+  "displayName": "Aimlock",
+  "description": "智能目标：把需求锁成可执行目标，按 Lock / Probe / Swarm 分档，先分析再改代码，文件快照禁止 git 分支；可调用 Blueprint、Swarm、Calctool，以及 Image 让智能体生成图片。",
+  "schemaVersion": "aimlock.skill.request/1.0",
+  "endpoint": "https://cli.tax/R3mQ8kWpXn",
+  "method": "POST",
+  "version": "v1.0.1",
+  "type": "Skill"
+}