@quolu/lattice 0.78.1 → 0.79.0

package/README.ja.md

@@ -162,7 +162,7 @@ release commitを既定branchへ着地・pushしてから、同じ版をregistry
 ```bash
 npm run ci
 npm run verify:release-commit
-npm publish --access public
+gh workflow run publish.yml --repo kitepon/Lattice --ref main
 npm install -g @quolu/lattice@<version>
 lattice --version
 lattice status --json
@@ -188,6 +188,9 @@ npm run check
 npm run ci
 ```
 
+最初にrootの依存を`npm ci`で導入します。`npm test`は内蔵sensorの依存とbuildを準備してから
+製品testを実行するため、隔離checkoutでも別のbuild手順は要りません。
+
 製品localの保守で必要な時だけ次を使います。
 
 ```bash
@@ -222,8 +225,23 @@ lattice status --json
 
 `state`は`uninitialized | ready | active_run | invalid`のいずれかです。`uninitialized`は
 正常な未初期化状態で、`next_action`が正規の初期authoring入口を返します。新規planはPhase監査と
-ToDo schedulingを分離し、全ToDoに設計メモを持つ`lattice.plan_create_input.v4`のcanonical
-JSON+LFを用意し、次で作成します。既存のv1〜v3は互換契約として維持され、`--schema-version`で取得できます。
+ToDo schedulingを分離し、全ToDoに設計メモを持つ`lattice.plan_create_input.v4`の
+repo内JSONを用意し、次で作成します。既存のv1〜v3は互換契約として維持され、`--schema-version`で取得できます。
+
+AIへ「Latticeで工程作って」と頼むと、製品hookが機能逆算の入口を示します。AIは最終成果と
+受入条件から必要な機能を逆向きにたどり、各ToDoが必要とする機能と作る機能を定義します。
+全体目的、後続の利用、未知の理由と次の問いも担当者へ渡します。同じ入口で既存storeへの
+新plan追加と、開発中にゴールが変わったplanの後継版作成まで行えます。
+
+```bash
+lattice plan backchain --schema --json
+lattice plan backchain --input .lattice/backchain.json --dry-run --json
+lattice plan backchain --input .lattice/backchain.json --json
+```
+
+`backchain.json`はrepo内の`lattice.plan_create_input.v4`を`authoring_ref`で参照します。
+機能の意味を判断するのは操作AIで、Latticeは宣言した機能・工程・依存の接続を検査します。
+旧planは従来どおり読めます。
 
 ```bash
 lattice plan create --schema-version 4 --json   # v4のJSON Schemaを取る（作成はしない）

package/README.md

@@ -175,6 +175,25 @@ AIの設定がまだ無い初回は`lattice setup --host claude --json`のよう
 
 ## Quick start
 
+Ask a configured AI host **「Latticeで工程作って」** to plan from an outcome. The
+Lattice prompt hook points the agent to `lattice plan backchain`: the agent starts
+with the final acceptance conditions, works backward through required capabilities,
+and defines what each ToDo needs and provides. The result carries the overall purpose
+and downstream consumers into `todo show` and `todo start`. Unknown capabilities keep
+their reason and next question. The same entry revises an active plan when the goal
+changes, preserving completed work that still satisfies the new goal.
+
+```bash
+lattice plan backchain --schema --json
+lattice plan backchain --input .lattice/backchain.json --dry-run --json
+lattice plan backchain --input .lattice/backchain.json --json
+```
+
+The input refers to an AI-authored `lattice.plan_create_input.v4` file in the same
+repository. Lattice validates the declared feature relationships and records them;
+the operating agent judges their meaning. Existing plans without a feature chain keep
+their previous behavior.
+
 Every project begins with typed discovery. Never guess from directory layout:
 
 ```bash
@@ -326,6 +345,9 @@ npm run check   # syntax + control-character gate
 npm run ci      # full gate
 ```
 
+The test entry builds the bundled sensor before running product fixtures. Install
+the root dependencies with `npm ci` once; the test entry prepares the sensor package.
+
 Product-local maintenance, when relevant:
 
 ```bash

package/bin/lattice.mjs

@@ -112,6 +112,37 @@ if (help !== null) {
   } catch (error) {
     process.exitCode = projectCliFailure(process.stderr, error);
   }
+} else if (args.length === 4 && args[0] === 'plan' && args[1] === 'backchain'
+  && args[2] === '--schema' && args[3] === '--json') {
+  const { backchainSchema } = await import('../src/plan-backchain.mjs');
+  const { projectCliFailure } = await import('../src/project-cli.mjs');
+  try {
+    process.stdout.write(`${JSON.stringify(await backchainSchema())}\n`);
+    process.exitCode = 0;
+  } catch (error) {
+    process.exitCode = projectCliFailure(process.stderr, error);
+  }
+} else if (args[0] === 'plan' && args[1] === 'backchain') {
+  const { matchFlagCommand } = await import('../src/todo-authoring-input.mjs');
+  const flags = matchFlagCommand(args, ['plan', 'backchain'], {
+    known: ['input', 'dry-run', 'json'], required: ['input'],
+    booleans: ['dry-run', 'json'],
+  });
+  if (flags === null || flags.json !== true) {
+    process.stderr.write(`lattice: unsupported command or arguments: ${args.join(' ')}\n`);
+    process.exitCode = 2;
+  } else {
+    const { runPlanBackchain } = await import('../src/plan-backchain.mjs');
+    const { projectCliFailure } = await import('../src/project-cli.mjs');
+    try {
+      process.exitCode = await runPlanBackchain({
+        cwd: process.cwd(), inputRef: flags.input, dryRun: flags['dry-run'] === true,
+        stdout: process.stdout, env: process.env,
+      });
+    } catch (error) {
+      process.exitCode = projectCliFailure(process.stderr, error);
+    }
+  }
 } else if (args.length === 2 && args[0] === 'factory-diagnostics' && args[1] === '--json') {
   const { buildFactoryDiagnostics } = await import('../src/factory-diagnostics.mjs');
   const diagnostics = await buildFactoryDiagnostics();

package/docs/schemas/lattice.plan_backchain.v1.schema.json

@@ -0,0 +1,103 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://github.com/kitepon/Lattice/blob/main/docs/schemas/lattice.plan_backchain.v1.schema.json",
+  "title": "lattice.plan_backchain.v1",
+  "description": "AI-authored backward feature chain. Start with the final outcome, declare each required capability and what supplies it, then bind every registered ToDo to the capabilities it needs and provides. Unknowns carry a reason and a question instead of blocking authoring.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema", "authoring_ref", "project_id", "plan_key", "plan_version", "goal", "features", "tasks", "chain_digest"],
+  "properties": {
+    "schema": { "const": "lattice.plan_backchain.v1" },
+    "authoring_ref": { "$ref": "#/$defs/repoRef" },
+    "project_id": { "$ref": "#/$defs/identifier" },
+    "plan_key": { "$ref": "#/$defs/identifier" },
+    "plan_version": { "$ref": "#/$defs/identifier" },
+    "goal": {
+      "type": "object", "additionalProperties": false,
+      "required": ["purpose", "outcome", "acceptance", "required_feature_ids"],
+      "properties": {
+        "purpose": { "$ref": "#/$defs/text" },
+        "outcome": { "$ref": "#/$defs/text" },
+        "acceptance": { "$ref": "#/$defs/text" },
+        "required_feature_ids": { "$ref": "#/$defs/nonemptyIds" }
+      }
+    },
+    "features": {
+      "type": "array", "minItems": 1, "maxItems": 2048,
+      "items": { "$ref": "#/$defs/feature" }
+    },
+    "tasks": {
+      "type": "array", "minItems": 1, "maxItems": 512,
+      "items": { "$ref": "#/$defs/task" }
+    },
+    "continuity": {
+      "type": "array", "maxItems": 512, "uniqueItems": true,
+      "description": "Optional goal-change decisions for predecessor tasks. A carry decision is an explicit AI judgment that previous work still satisfies the revised goal; reset and retire remain available without proving equivalence.",
+      "items": { "$ref": "#/$defs/continuity" }
+    },
+    "chain_digest": { "$ref": "#/$defs/digest" }
+  },
+  "$defs": {
+    "identifier": { "type": "string", "pattern": "^[0-9A-Za-z](?:[0-9A-Za-z._-]{0,127})$" },
+    "digest": { "type": "string", "pattern": "^[0-9a-f]{64}$" },
+    "text": { "type": "string", "minLength": 1, "maxLength": 16384, "pattern": "\\S" },
+    "repoRef": {
+      "type": "string", "minLength": 1, "maxLength": 1024,
+      "pattern": "^(?!/)(?!.*(?:^|/)\\.{1,2}(?:/|$))(?!.*\\\\)(?!.*[\\u0000-\\u001f\\u007f])[^/]+(?:/[^/]+)*$"
+    },
+    "ids": { "type": "array", "maxItems": 2048, "uniqueItems": true, "items": { "$ref": "#/$defs/identifier" } },
+    "nonemptyIds": { "allOf": [{ "$ref": "#/$defs/ids" }, { "minItems": 1 }] },
+    "provider": {
+      "oneOf": [
+        {
+          "type": "object", "additionalProperties": false,
+          "required": ["kind", "task_id"],
+          "properties": { "kind": { "const": "task" }, "task_id": { "$ref": "#/$defs/identifier" } }
+        },
+        {
+          "type": "object", "additionalProperties": false,
+          "required": ["kind", "evidence_ref"],
+          "properties": { "kind": { "const": "existing" }, "evidence_ref": { "$ref": "#/$defs/repoRef" } }
+        },
+        {
+          "type": "object", "additionalProperties": false,
+          "required": ["kind", "reason", "question"],
+          "properties": {
+            "kind": { "const": "unknown" },
+            "reason": { "$ref": "#/$defs/text" },
+            "question": { "$ref": "#/$defs/text" }
+          }
+        }
+      ]
+    },
+    "feature": {
+      "type": "object", "additionalProperties": false,
+      "required": ["feature_id", "capability", "acceptance", "requires_feature_ids", "provider"],
+      "properties": {
+        "feature_id": { "$ref": "#/$defs/identifier" },
+        "capability": { "$ref": "#/$defs/text" },
+        "acceptance": { "$ref": "#/$defs/text" },
+        "requires_feature_ids": { "$ref": "#/$defs/ids" },
+        "provider": { "$ref": "#/$defs/provider" }
+      }
+    },
+    "task": {
+      "type": "object", "additionalProperties": false,
+      "required": ["task_id", "requires_feature_ids", "provides_feature_ids"],
+      "properties": {
+        "task_id": { "$ref": "#/$defs/identifier" },
+        "requires_feature_ids": { "$ref": "#/$defs/ids" },
+        "provides_feature_ids": { "$ref": "#/$defs/nonemptyIds" }
+      }
+    },
+    "continuity": {
+      "type": "object", "additionalProperties": false,
+      "required": ["task_id", "policy", "reason"],
+      "properties": {
+        "task_id": { "$ref": "#/$defs/identifier" },
+        "policy": { "enum": ["carry", "reset", "retire"] },
+        "reason": { "$ref": "#/$defs/text" }
+      }
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quolu/lattice",
-  "version": "0.78.1",
+  "version": "0.79.0",
   "description": "Schedulability compiler for multi-agent development: observe real code boundaries, refactor the conflicting seam, recompile the plan for parallel execution",
   "author": {
     "name": "Quo / クオ at kitepon.dev",
@@ -30,6 +30,7 @@
     "docs/schemas/lattice.plan_create_input.v3.schema.json",
     "docs/schemas/lattice.plan_create_input.v4.schema.json",
     "docs/schemas/lattice.plan_scope_review.v1.schema.json",
+    "docs/schemas/lattice.plan_backchain.v1.schema.json",
     "docs/schemas/lattice.todo_revision.v2.schema.json",
     "docs/schemas/lattice.todo_revision_set.v3.schema.json",
     "docs/schemas/lattice.phase_todo_revision.v3.schema.json",
@@ -79,8 +80,8 @@
     "prepack": "npm --prefix sensor run build",
     "verify:release-commit": "node scripts/verify-release-commit.mjs",
     "prepublishOnly": "npm run verify:release-commit",
-    "test": "node scripts/run-product-tests.mjs",
-    "test:profile": "node scripts/run-product-tests.mjs",
+    "test": "npm --prefix sensor ci && npm --prefix sensor run build && node scripts/run-product-tests.mjs",
+    "test:profile": "npm --prefix sensor ci && npm --prefix sensor run build && node scripts/run-product-tests.mjs",
     "test:sensor": "npm --prefix sensor test",
     "check": "node scripts/check-syntax.mjs",
     "ci": "npm run check:docs && npm run test && npm run test:sensor && npm run check && npm run check:cli-surface && npm run check:open-questions && npm run check:reachability && npm run verify:todo-store",

package/src/cli-help.mjs

@@ -29,6 +29,9 @@ Commands:
       # 結果へdispatch_shapeを載せる。--serialization-reviewedは互換のため受理するだけで門ではない
   create --schema --json             # 既定は最新版（v4）のJSON Schemaを返す
   create --schema-version <1|2|3|4> --json
+  backchain --schema --json         # 最終成果から必要な機能を逆算する入力契約
+  backchain --input <file> [--dry-run] --json
+      # 各工程の必要・提供機能を照合し、初回又は既存storeへのplan登録まで行う
   show <plan_key> --json             # task・依存・phase・状態をplan本体から1コマンドで投影する
   compile --request <request.json>
   compile --schema --json            # lattice.run_request.v1 の JSON Schema を出す
@@ -231,6 +234,7 @@ const SUBCOMMAND_USAGE = Object.freeze({
   'plan create': 'plan create --input <file> [--serialization-reviewed] | --schema --json | --schema-version <1|2|3|4> --json',
   'plan show': 'plan show <plan_key> --json',
   'plan scope-review': 'plan scope-review --plan-input <plan-create-or-extraction.json> --review <scope-review.json> --json | --schema --json',
+  'plan backchain': 'plan backchain --input <file> [--dry-run] --json | --schema --json',
   'plan compile': 'plan compile --request <request.json> | --schema --json',
   'plan verify': 'plan verify --request <request.json> --plan <plan.json>',
   'run start': 'run start --request <request.json> --executor <adapter>'

package/src/hooks-cli.mjs

@@ -11,6 +11,7 @@ import { fileURLToPath } from 'node:url';
 import { hostPaths } from './setup-hosts.mjs';
 
 const INFO = 'INFO: このrepoにはLattice sensor index（.lattice/sensor/）があります。コード構造の調査はsensor入口（MCP: lattice_sensor_explore 等／CLI: lattice sensor）を優先できます。';
+const BACKCHAIN_INFO = 'Lattice工程作成: 最終成果の目的と受入条件から必要な機能を逆算し、各機能の前提・提供元と各ToDoの必要・提供機能を定義する。未知は理由と次の問いを残す。まず lattice status --json と lattice plan backchain --schema --json を読み、repo内のauthoring JSONと機能契約を作る。lattice plan backchain --input <機能契約.json> --json が初回作成・既存storeへの追加・ゴール変更後の工程修正まで行う。AIが意味を判断し、Latticeは宣言の接続と記録を検査する。';
 const HOSTS = new Set(['claude', 'codex', 'cursor']);
 const HOST_USAGE = 'usage: lattice hooks <install|status|uninstall|emit> --host <claude|codex|cursor>';
 const MAX_STDIN_BYTES = 64 * 1024;
@@ -970,11 +971,11 @@ async function acquireClaim(claim) {
   }
 }
 
-function outputLine(host) {
-  if (host === 'claude') return `${INFO}\n`;
-  if (host === 'cursor') return `${JSON.stringify({ additional_context: INFO })}\n`;
+function outputLine(host, message = INFO) {
+  if (host === 'claude') return `${message}\n`;
+  if (host === 'cursor') return `${JSON.stringify({ additional_context: message })}\n`;
   return `${JSON.stringify({
-    hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext: INFO },
+    hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext: message },
   })}\n`;
 }
 
@@ -986,16 +987,25 @@ async function writeOutput(stdout, line) {
 
 async function emit(host, env, stdin, stdout, spawnImpl, gitTimeoutMs, testHooks) {
   if (env.LATTICE_HOOKS === 'off') return 0;
-  let state;
-  try { state = await secureStateDirectory(env, ['lattice', 'hooks']); } catch {
-    stdout.write('Lattice hooks: state directory unavailable\n');
-    return 0;
-  }
   let event;
   try { event = await readHookInput(stdin); } catch (error) {
+    let state;
+    try { state = await secureStateDirectory(env, ['lattice', 'hooks']); } catch {
+      stdout.write('Lattice hooks: state directory unavailable\n');
+      return 0;
+    }
     await recordOrDiagnose(state, stdout, error.message, 'cannot record invalid stdin');
     return 0;
   }
+  if (typeof event.prompt === 'string' && /Latticeで工程(?:を)?作って/iu.test(event.prompt)) {
+    await writeOutput(stdout, outputLine(host, BACKCHAIN_INFO));
+    return 0;
+  }
+  let state;
+  try { state = await secureStateDirectory(env, ['lattice', 'hooks']); } catch {
+    stdout.write('Lattice hooks: state directory unavailable\n');
+    return 0;
+  }
   const git = await gitRoot(event.cwd, spawnImpl, gitTimeoutMs);
   if (git.kind === 'not_git') return 0;
   if (git.kind === 'error') {