@sabaiway/agent-workflow-kit 12.4.0 → 13.0.0

package/CHANGELOG.md

@@ -4,6 +4,66 @@ Semantically versioned ([semver](https://semver.org)), newest first. The `versio
 is the current release. `upgrade` mode reads a project's `docs/ai/.workflow-version` and applies
 every `migrations/<version>-<slug>.md` newer than it, in semver order.
 
+## 13.0.0 — a plan proves its own ground: `plan-shape` judges a plan's rows against its epic story's claims in both arms and `--in-flight`, the claim relation lives in one leaf, and the containment rule is one positive predicate (AD-139)
+
+**MAJOR: the containment rule refuses a row or anchor path spelling 12.4.0 accepted — a trailing or doubled slash, a
+`.` segment — so a consumer's declared `--in-flight` gate can turn red with no edit of theirs (the refusal names the
+row and the rule; no migration note, as for every kit MAJOR since 4.0.0 — the class AD-117 and AD-133 called MAJOR),
+and the story relation joins the structural set, so a consumer already on the 12.4.0 epic tier can go red the same
+way with no edit of theirs (each code's reach is stated in the bullets below); three new shipped leaves, one new
+structural rule set, no deployed gate line's TEXT changes.** The epic
+tier (12.4.0) gave a story a ledger of claims; the bar "a plan stays inside its story's claims" lived in prose, and
+the last bar this epic wrote down drifted inside a day. The rung is now a tool, enforced where a dispatch is spent: `--in-flight` is already the gate
+this family runs before every dispatch. The contract is `docs/ai/specs/kit/plan-shape-ownership.md` (live, revision 1,
+S1–S11 bound) beside `plan-review-loop` revision 9.
+
+- **The story line.** A plan carrying an epic story names it with exactly one line `Story: S<N> of <ID>` inside
+  `## Goal and boundary`, `<ID>` the epic's file stem under `docs/ai/epics/`. Two lines refuse `story-line`; an
+  unknown epic or story id refuses `story-unknown` by name; a landed epic refuses `story-epic-landed`. Zero lines is
+  a storyless plan and stays legal — judged as today plus the collision half. The plan's own story is looked up in
+  the full record list, landed rows included; its `state:` is never read.
+- **ONE relation, in the STRUCTURAL set.** Over every concrete row path after glob expansion, against every
+  not-landed story of every open epic minus the plan's own: an `owns` overlap refuses `story-owns`; a `shared`
+  overlap inside the plan's own epic refuses `story-shared` unless a transitive `depends-on` edge orders the two
+  in either direction; a storyless plan against a `shared` claim refuses the same way (name the story); a
+  cross-epic `shared` overlap is not judged (the epic tier prints it). For a storied plan, an in-scope row path —
+  the declared source-size practice's roots, extensions and exclusions — that no own claim covers refuses
+  `story-scope`; the package-content pin path is covered by the shipped `create` or `delete` row it pins and is
+  never claimed by a story. `checkPlan`, `verifyPlan` and `checkPlanStructure` all carry it, so `--check`,
+  `--verify` and `--check --in-flight` agree.
+- **Facts.** `openRepo` reads `docs/ai/epics/` once per run through the epic sweep's own no-follow door, and
+  `buildFacts` hands the judge `stories` (one record per valid story row of every open epic: `{ path, id, line, state, claims,
+  reachable }`), `landedEpics` (the file stems the sweep read as landed) and `storeRefusal`. Only ENOENT reads as
+  an absent store; a symlinked root, a regular file, ENOTDIR, any other error, a failed read, an unreadable `.md`
+  entry, a frontmatter the header reader refuses, an open epic the shape check refuses or a state outside the
+  closed set refuse EVERY judged plan `story-store`. A facts object with no `stories` field (the bare callers)
+  leaves the relation unjudged.
+- **The pin exemption (`plan-review-loop` revision 9, S34).** Several `modify` rows whose OWN path is one
+  package-content pin path may own it — the ONE exemption to `duplicate-path`: a single pin row owes nothing; with
+  two or more, every one binds in ledger order the nearest untaken shipped `create` or `delete` row above it whose
+  package pin is that path, and a row that finds none refuses `pin-unbound`. A sweep expansion never rides it; the
+  `before`/`after` totals count each concrete path once; a judge with no `pathFacts` admits repeated `modify` pin
+  rows unjudged; a duplicate involving a `create` or `delete` still refuses.
+- **Containment enumerated by proof.** A row or anchor path is admitted only when it has no backslash and every
+  `/`-separated segment is non-empty and neither `.` nor `..` — one predicate instead of an exclusion list, after
+  `./x` (plan review) and `x/` (diff review, confirmed live) each walked around a claim; a leading slash was
+  already refused by 12.4.0's own predicate.
+- **Three leaves, no cycle, no claim primitive written twice.** `tools/claim-relation.mjs` (`expandClaim`,
+  `hasPathOverlap`, `findReachable`, `listStories`, `unique` — `plan-shape.mjs` re-exports `unique` so every import
+  site stands), `tools/epic-store.mjs` (`EPICS_REL`, `readEpicEntries` — the epic CLI's door, unchanged — and
+  `readEpicStore`, the facts half's no-follow probe), `tools/plan-shape-ownership.mjs` (`readStoryLine`,
+  `checkStoryOwnership`, `PIN_FILE`, `PIN_VERBS`). `epic-shape-ledger.mjs` and `epic-shape-cli.mjs` keep their
+  findings and counts byte for byte under their unchanged suites; the sweep result gains `landedEpics` beside
+  `counts`. Tarball pin 301 → 304. Every touched shipped module stays under the 400-line cap (`plan-shape.mjs` 384);
+  the kit's recorded aggregate rises by the three leaves and their suites, the reason recorded in the ratchet.
+- **Recorded debt (queue).** `openRepo` walks the repository before the store probe, so an EACCES directory
+  anywhere exits 2 before `story-store` can be named (refuse-direction, pre-existing); the robustness coverage
+  table reads a filesystem errno as a process-launch outcome; a delegate read its own sandbox's spawn limit as a
+  reason to stop a slice; a near-miss story line (`- Story: …`, the bullet marker the canon's own sentence sits
+  under) reads as a storyless plan instead of refusing; the one-line read describer is written twice by the store
+  extraction (`describeRead` in the epic CLI and in the store leaf); a storied plan whose only pin-path row ships
+  no `create` or `delete` above it refuses `story-scope` with no repair inside the rule.
+
 ## 12.4.0 — the epic tier gets its checker: `epic-shape` judges a capped concept file by one altitude predicate and one claim relation, renders its review brief, folds the findings by the same predicate, and closes it by rewriting one byte range (AD-138)
 
 **MINOR: one new tool, four verbs, four shipped modules; no deployed gate line changes its verdict.** The epic this

package/SKILL.md

@@ -3,7 +3,7 @@ name: agent-workflow-kit
 description: Deploy or upgrade a portable AI-agent memory-and-workflow system in any project. Use when the user wants to bootstrap `docs/ai/` + an entry-point `AGENTS.md` (+ `CLAUDE.md` alias) + cap/archive/index enforcement in a new or existing repo, set up the Memory Map and session protocols, install the docs-rotation pre-commit hook, or run `/agent-workflow-kit` / `/agent-workflow-kit upgrade`. Triggers on phrases like "set up the memory system", "deploy the AI workflow here", "bootstrap docs/ai", "upgrade the workflow".
 disable-model-invocation: true
 metadata:
-  version: '12.4.0'
+  version: '13.0.0'
 ---
 
 # agent-workflow-kit

package/capability.json

@@ -3,7 +3,7 @@
   "schema": 1,
   "name": "agent-workflow-kit",
   "kind": "composition-root",
-  "version": "12.4.0",
+  "version": "13.0.0",
   "provides": [],
   "roles": {},
   "detect": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sabaiway/agent-workflow-kit",
-  "version": "12.4.0",
+  "version": "13.0.0",
   "description": "Portable, cross-agent memory & workflow for AI coding agents — Claude Code, Codex, Cursor, Devin Desktop. One command deploys an AGENTS.md entry point + docs/ai context with cap/archive/index enforcement into any repo.",
   "keywords": [
     "ai-agents",

package/tools/claim-relation.mjs

@@ -0,0 +1,33 @@
+const OPEN = 'open';
+const CLAIM_FIELDS = Object.freeze(['owns', 'shared']);
+const TRAILING_SLASH = /\/$/;
+const SOURCE_EXTENSION = /^(.*[^/])(\.[^./]+)$/;
+const TEST_FILE = /\.test\.[^/]+$/;
+const TEST_SUFFIX = '.test';
+
+export const unique = (items) => [...new Set(items)];
+
+export const expandClaim = (path) => {
+  const source = SOURCE_EXTENSION.exec(path);
+  return source && !TEST_FILE.test(path)
+    ? [path, `${source[1]}${TEST_SUFFIX}${source[2]}`, `${source[1]}${TEST_SUFFIX}/`] : [path];
+};
+export const hasPathOverlap = (left, right) => {
+  const a = left.replace(TRAILING_SLASH, '');
+  const b = right.replace(TRAILING_SLASH, '');
+  return a === b || a.startsWith(`${b}/`) || b.startsWith(`${a}/`);
+};
+export const findReachable = (graph, pending, visited = new Set()) => {
+  const unseen = unique(pending.filter((id) => !visited.has(id)));
+  if (unseen.length === 0) return visited;
+  return findReachable(graph, unseen.flatMap((id) => graph.get(id) ?? []), new Set([...visited, ...unseen]));
+};
+const getClaims = (row) => CLAIM_FIELDS.flatMap((field) => row[field].map((path) => ({ field, path, ground: expandClaim(path) })));
+
+export const listStories = (epics) => epics.filter((epic) => epic.state === OPEN).flatMap((epic) => {
+  const graph = new Map(epic.rows.map((row) => [row.id, row.dependsOn]));
+  return epic.rows.filter((row) => row.valid).map((row) => ({
+    path: epic.path, id: row.id, line: row.line, state: row.state,
+    claims: getClaims(row), reachable: findReachable(graph, row.dependsOn),
+  }));
+});

package/tools/epic-shape-cli.mjs

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
-import { constants, openSync, closeSync, fstatSync, readdirSync, writeSync, ftruncateSync } from 'node:fs';
-import { basename, dirname, join, resolve } from 'node:path';
+import { constants, openSync, closeSync, fstatSync, writeSync, ftruncateSync } from 'node:fs';
+import { basename, dirname, resolve } from 'node:path';
 import { fail } from '../references/scripts/markdown-blocks.mjs';
 import { isDirectRun } from './direct-run.mjs';
 import { readRegularFileNoFollow } from './fs-read-nofollow.mjs';
+import { readEpicEntries } from './epic-store.mjs';
 import { checkEpic } from './epic-shape.mjs';
 import { checkClaims, sweepSiblings, judgeClose, STORE_PATH, QUEUE_PATH } from './epic-shape-ledger.mjs';
 import { renderBrief, foldFindings } from './epic-shape-brief.mjs';
@@ -18,7 +19,6 @@ const HELP_FLAG = '--help';
 const HELP_ARITY = 1;
 const VERB_ARITY = 2;
 const FIRST_LINE = 1;
-const MARKDOWN_SUFFIX = '.md';
 const PREFIX = 'epic-shape:';
 const INFO = 'info';
 const STORE_TO_PROJECT = '../../..';
@@ -60,15 +60,6 @@ const readInput = (path, read, writable) => {
   if (result.outcome !== 'ok') throw makeFailure(path, 'read', describeRead(result));
   return result;
 };
-const readDirectory = (root, read) => readdirSync(root, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name)).map((entry) => {
-  const name = entry.name;
-  if (entry.isDirectory()) return { name, outcome: 'directory' };
-  if (!name.endsWith(MARKDOWN_SUFFIX)) return { name, text: '' };
-  const result = read(join(root, name));
-  if (result.outcome === 'ok') return { name, text: result.content };
-  if (result.outcome === 'foreign') return { name, outcome: 'non-regular', kind: result.className };
-  return { name, outcome: 'unreadable', reason: describeRead(result) };
-});
 const readQueue = (path, read) => {
   if (!STORE_PATH.test(path)) return { outcome: 'unreadable', reason: 'epic is outside a project store' };
   const queuePath = resolve(dirname(path), STORE_TO_PROJECT, QUEUE_PATH);
@@ -104,7 +95,7 @@ const runFold = (input, path, io) => {
   return EXIT.accept;
 };
 const runEpic = (verb, input, path, io) => {
-  const entries = readDirectory(dirname(path), io.read).filter((entry) => entry.name !== basename(path));
+  const entries = readEpicEntries(dirname(path), io.read).filter((entry) => entry.name !== basename(path));
   const shape = checkEpic(input.content, path);
   const sweep = sweepSiblings(entries, dirname(path));
   const claims = shape.findings.length === 0 && sweep.ok

package/tools/epic-shape-ledger.mjs

@@ -2,7 +2,7 @@ import { posix } from 'node:path';
 import { tokenizeMarkdown } from '../references/scripts/markdown-blocks.mjs';
 import { parseHeader, checkEpic } from './epic-shape.mjs';
 import { auditQueue } from './queue-audit.mjs';
-import { unique } from './plan-shape.mjs';
+import { hasPathOverlap, findReachable, listStories, unique } from './claim-relation.mjs';
 
 const FIRST_LINE = 1;
 const ERROR = 'error';
@@ -11,14 +11,9 @@ const OPEN = 'open';
 const LANDED = 'landed';
 const EPIC = 'epic';
 const OWN = 'owns';
-const CLAIM_FIELDS = Object.freeze([OWN, 'shared']);
 const FRONT_DELIMITER = '---';
 const CR_END = /\r$/;
 const MARKDOWN_SUFFIX = '.md';
-const TRAILING_SLASH = /\/$/;
-const SOURCE_EXTENSION = /^(.*[^/])(\.[^./]+)$/;
-const TEST_FILE = /\.test\.[^/]+$/;
-const TEST_SUFFIX = '.test';
 export const STORE_PATH = /^(?:(.*)\/)?docs\/ai\/epics\/([^/]+)\.md$/;
 export const QUEUE_PATH = 'docs/plans/queue.md';
 const TOKEN_EDGE = '[\\p{L}\\p{N}_-]';
@@ -29,14 +24,10 @@ const finishJudgement = (findings, data = {}) => ({ ...data, ok: !findings.some(
 const nameFindings = (findings, path) => findings.map((finding) => makeFinding(path, finding.line, finding.code, finding.message));
 const getIdentity = (story) => JSON.stringify([story.path, story.id]);
 
-const findReachable = (graph, pending, visited = new Set()) => {
-  const unseen = unique(pending.filter((id) => !visited.has(id)));
-  if (unseen.length === 0) return visited;
-  return findReachable(graph, unseen.flatMap((id) => graph.get(id) ?? []), new Set([...visited, ...unseen]));
-};
-const readGraph = (epic, rows) => {
+const readGraph = (epic, rows, stories) => {
   const graph = new Map(rows.map((row) => [row.id, row.dependsOn]));
-  const reachable = new Map(rows.map((row) => [row.id, findReachable(graph, row.dependsOn)]));
+  const byLine = new Map(stories.map((story) => [story.line, story.reachable]));
+  const reachable = new Map(rows.map((row) => [row.id, byLine.get(row.line) ?? findReachable(graph, row.dependsOn)]));
   const unknowns = rows.flatMap((row) => row.dependsOn.filter((id) => !graph.has(id))
     .map((id) => makeFinding(epic.path, row.line, 'dependency-id', `${row.id} depends on absent story ${id}`)));
   const cyclic = rows.filter((row) => reachable.get(row.id).has(row.id));
@@ -49,17 +40,6 @@ const readGraph = (epic, rows) => {
   return { reachable, findings: [...unknowns, ...cycles] };
 };
 
-const expandClaim = (path) => {
-  const source = SOURCE_EXTENSION.exec(path);
-  return source && !TEST_FILE.test(path)
-    ? [path, `${source[1]}${TEST_SUFFIX}${source[2]}`, `${source[1]}${TEST_SUFFIX}/`] : [path];
-};
-const hasPathOverlap = (left, right) => {
-  const a = left.replace(TRAILING_SLASH, '');
-  const b = right.replace(TRAILING_SLASH, '');
-  return a === b || a.startsWith(`${b}/`) || b.startsWith(`${a}/`);
-};
-const getClaims = (row) => CLAIM_FIELDS.flatMap((field) => row[field].map((path) => ({ field, path, ground: expandClaim(path) })));
 const hasClaimOverlap = (left, right) => left.ground.some((a) => right.ground.some((b) => hasPathOverlap(a, b)));
 const checkPair = (left, right) => {
   if (getIdentity(left) === getIdentity(right)) return [];
@@ -79,13 +59,12 @@ const checkPair = (left, right) => {
 export const checkClaims = (epics) => {
   const parsed = epics.map((epic) => {
     const rows = epic.rows;
-    const graph = readGraph(epic, rows);
+    const stories = listStories([epic]);
+    const graph = readGraph(epic, rows, stories);
     const findings = rows.filter((row) => !row.valid)
       .map((row) => makeFinding(epic.path, row.line, 'row-grammar', `${row.id} has invalid story fields or claim tokens`));
-    const stories = epic.state === OPEN ? rows.filter((row) => row.valid && row.state !== LANDED).map((row) => ({
-      path: epic.path, id: row.id, line: row.line, claims: getClaims(row), reachable: graph.reachable.get(row.id),
-    })) : [];
-    return { stories, findings: [...nameFindings(epic.findings, epic.path), ...findings, ...graph.findings] };
+    return { stories: stories.filter((story) => story.state !== LANDED),
+      findings: [...nameFindings(epic.findings, epic.path), ...findings, ...graph.findings] };
   });
   const stories = parsed.flatMap((epic) => epic.stories);
   const collisions = stories.flatMap((left, index) => stories.slice(index + FIRST_LINE).flatMap((right) => checkPair(left, right)));
@@ -122,19 +101,20 @@ const readSibling = (entry, root) => {
   if (![OPEN, LANDED].includes(header.fields.state)) {
     return { read: 0, skipped: 0, epics: [], findings: [makeFinding(path, FIRST_LINE, 'sibling-state', 'epic state is missing or outside open and landed')] };
   }
-  if (header.fields.state === LANDED) return { read: FIRST_LINE, skipped: 0, epics: [], findings: [] };
+  if (header.fields.state === LANDED) return { read: FIRST_LINE, skipped: 0, epics: [], findings: [], landedEpics: [entry.name.slice(0, -MARKDOWN_SUFFIX.length)] };
   const { epic, findings } = checkEpic(entry.text, path);
   return { read: FIRST_LINE, skipped: 0, epics: findings.length ? [] : [epic], findings: nameFindings(findings, path) };
 };
 
 export const sweepSiblings = (entries, root) => {
   if (!Array.isArray(entries)) {
-    return finishJudgement([makeFinding(root, FIRST_LINE, 'sibling-read', 'the direct entry list is unreadable')], { root, epics: [], counts: { epicsRead: 0, skipped: 0 } });
+    return finishJudgement([makeFinding(root, FIRST_LINE, 'sibling-read', 'the direct entry list is unreadable')], { root, epics: [], counts: { epicsRead: 0, skipped: 0 }, landedEpics: [] });
   }
   const results = entries.map((entry) => readSibling(entry, root));
   const epics = results.flatMap((result) => result.epics);
   return finishJudgement(results.flatMap((result) => result.findings), {
     root, epics, counts: { epicsRead: results.reduce((sum, result) => sum + result.read, 0), skipped: results.reduce((sum, result) => sum + result.skipped, 0) },
+    landedEpics: results.flatMap((result) => result.landedEpics ?? []),
   });
 };
 

package/tools/epic-store.mjs

@@ -0,0 +1,33 @@
+import { lstatSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { describeNonRegular, readRegularFileNoFollow } from './fs-read-nofollow.mjs';
+
+export const EPICS_REL = 'docs/ai/epics';
+const MARKDOWN_SUFFIX = '.md';
+const ABSENT_CODE = 'ENOENT';
+const REGULAR_FILE = 'regular file';
+const describeRead = (result) => result.code ?? result.className ?? result.outcome;
+const refuseStore = (error) => ({ outcome: 'refused', reason: error?.code ?? error?.message ?? String(error) });
+
+export const readEpicEntries = (root, read) => readdirSync(root, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name)).map((entry) => {
+  const name = entry.name;
+  if (entry.isDirectory()) return { name, outcome: 'directory' };
+  if (!name.endsWith(MARKDOWN_SUFFIX)) return { name, text: '' };
+  const result = read(join(root, name));
+  if (result.outcome === 'ok') return { name, text: result.content };
+  if (result.outcome === 'foreign') return { name, outcome: 'non-regular', kind: result.className };
+  return { name, outcome: 'unreadable', reason: describeRead(result) };
+});
+
+export const readEpicStore = (projectRoot, read = readRegularFileNoFollow) => {
+  const root = join(projectRoot, EPICS_REL);
+  const probe = (() => {
+    try { return { stats: lstatSync(root) }; }
+    catch (error) { return { result: error?.code === ABSENT_CODE ? { outcome: 'absent', entries: [] } : refuseStore(error) }; }
+  })();
+  if (probe.stats?.isDirectory()) {
+    try { return { outcome: 'ok', entries: readEpicEntries(root, read) }; }
+    catch (error) { return refuseStore(error); }
+  }
+  return probe.result ?? { outcome: 'refused', reason: probe.stats.isFile() ? REGULAR_FILE : describeNonRegular(probe.stats) };
+};

package/tools/plan-shape-facts.mjs

@@ -4,13 +4,18 @@ import { readRegularFileNoFollow } from './fs-read-nofollow.mjs';
 import { classIds, readShippedRobustnessLiterals } from './robustness-literals.mjs';
 import { segmentPrefixOf, validateSourceSizeConfig } from './source-size-config.mjs';
 import { getLineCount, isSweep, resolveAnchorCandidates, unique } from './plan-shape.mjs';
+import { listStories } from './claim-relation.mjs';
+import { EPICS_REL, readEpicStore } from './epic-store.mjs';
+import { sweepSiblings } from './epic-shape-ledger.mjs';
+import { PIN_FILE } from './plan-shape-ownership.mjs';
 
 const SOURCE_SIZE_REL = 'docs/ai/source-size.json';
 const PACKAGE_FILE = 'package.json';
-const PIN_FILE = 'package-content.test.mjs';
 const EXCLUDED_DIRECTORIES = new Set(['.git', 'node_modules']);
 const NEGATED_CLASS = /\[[!^]/;
 const UNSUPPORTED_GLOB = /[()\\\u0000-\u001f]/;
+const STORE_REFUSED = 'refused';
+const FINDING_SEPARATOR = '; ';
 
 const usageError = (message, scope = 'repository') => Object.assign(new Error(message), { exitCode: 2, scope });
 const planError = (message) => usageError(message, 'plan');
@@ -200,18 +205,31 @@ const describePath = (root, path, practice, repoFiles, packageCache) => {
   };
 };
 
+const readStoryFacts = (root) => {
+  const store = readEpicStore(root);
+  if (store.outcome === STORE_REFUSED) return { stories: [], landedEpics: [], storeRefusal: `${EPICS_REL}: ${store.reason}` };
+  const sweep = sweepSiblings(store.entries, EPICS_REL);
+  return {
+    stories: sweep.ok ? listStories(sweep.epics) : [],
+    landedEpics: sweep.ok ? sweep.landedEpics : [],
+    storeRefusal: sweep.ok ? null : sweep.findings.map((finding) => finding.message).join(FINDING_SEPARATOR),
+  };
+};
+
 export const openRepo = (root, { robustnessDeps } = {}) => {
   const repoRoot = realpathSync(root);
-  return { repoRoot, repoFiles: walkRegularFiles(repoRoot), practice: loadPractice(repoRoot), robustClasses: loadRobustClasses(robustnessDeps), packageCache: new Map() };
+  return { repoRoot, repoFiles: walkRegularFiles(repoRoot), practice: loadPractice(repoRoot), robustClasses: loadRobustClasses(robustnessDeps),
+    packageCache: new Map(), ...readStoryFacts(repoRoot) };
 };
 
 export const expandSweepPaths = (root, patterns) => expandPatterns(walkRegularFiles(realpathSync(root)), patterns);
 
 export const buildFacts = (root, { paths = [], robustnessDeps, repo = openRepo(root, { robustnessDeps }) } = {}) => {
-  const { repoRoot, repoFiles, practice, robustClasses, packageCache } = repo;
+  const { repoRoot, repoFiles, practice, robustClasses, packageCache, stories, landedEpics, storeRefusal } = repo;
   const expansions = expandPatterns(repoFiles, paths.filter(isSweep));
   const allPaths = unique([...paths, ...Object.values(expansions).flat()]);
   const pathFacts = Object.fromEntries(allPaths.map((path) => [path, describePath(repoRoot, path, practice, repoFiles, packageCache)]));
   const candidates = (suffix, precedingPaths = []) => resolveAnchorCandidates(repoFiles, suffix, precedingPaths);
-  return { capDeclared: practice.capDeclared, cap: practice.cap, robustClasses, pathFacts, expansions, repoFiles, candidates };
+  return { capDeclared: practice.capDeclared, cap: practice.cap, robustClasses, pathFacts, expansions, repoFiles, candidates,
+    stories, landedEpics, storeRefusal };
 };

package/tools/plan-shape-ownership.mjs

@@ -0,0 +1,83 @@
+import { posix } from 'node:path';
+import { hasPathOverlap } from './claim-relation.mjs';
+
+const STORY_LINE = /^Story: (S[1-9]\d*) of ([^\s/]+)$/;
+const STORY_FIELDS = 'stories';
+export const PIN_FILE = 'package-content.test.mjs';
+const MARKDOWN_SUFFIX = '.md';
+const FIRST_LINE = 1;
+const LANDED = 'landed';
+const OWNS = 'owns';
+const SHARED = 'shared';
+const STRING_TYPE = 'string';
+export const PIN_VERBS = new Set(['create', 'delete']);
+const CODES = Object.freeze({ line: 'story-line', store: 'story-store', landed: 'story-epic-landed',
+  unknown: 'story-unknown', owns: 'story-owns', shared: 'story-shared', scope: 'story-scope' });
+const ONE_STORY = 'the plan names its story with one line';
+const NAME_STORY = 'name the story that carries the file';
+const ORDER_STORIES = 'declare a transitive depends-on order between the stories';
+const makeFinding = (line, code, message, rowId = null) => ({ line, code, message, rowId });
+const sortFindings = (findings) => ({ findings: findings.sort((left, right) => left.line - right.line) });
+const hasIdentity = (left, right) => left.path === right.path && left.id === right.id;
+const hasClaimCover = (claim, path) => claim.ground.some((ground) => hasPathOverlap(path, ground));
+const hasOwnCover = (own, path) => own.claims.some((claim) => hasClaimCover(claim, posix.normalize(path)));
+
+export const readStoryLine = (lines) => {
+  const [story = null, second] = lines.flatMap(({ text, line }) => {
+    const match = STORY_LINE.exec(text.trim());
+    if (!match) return [];
+    const [, id, epic] = match;
+    return [{ id, epic, line }];
+  });
+  return { story, findings: second ? [makeFinding(second.line, CODES.line, ONE_STORY)] : [] };
+};
+
+const findOwnStory = (story, facts) => {
+  if (!story) return { own: null, findings: [] };
+  const epics = facts.stories.filter((record) => posix.basename(record.path, MARKDOWN_SUFFIX) === story.epic);
+  const own = epics.find((record) => record.id === story.id) ?? null;
+  if (facts.landedEpics?.includes(story.epic)) {
+    return { own: null, findings: [makeFinding(story.line, CODES.landed, `${story.epic} is landed; name a story of an open epic`)] };
+  }
+  if (!own) {
+    const name = epics.length ? `${story.epic} ${story.id}` : story.epic;
+    return { own: null, findings: [makeFinding(story.line, CODES.unknown, `${name} is unknown; name a story present in an open epic`)] };
+  }
+  return { own, findings: [] };
+};
+
+const checkCollision = (row, path, record, claim, own) => {
+  if (!hasClaimCover(claim, posix.normalize(path))) return [];
+  const message = `${row.id} path ${path} overlaps ${record.path} ${record.id} ${claim.field} ${claim.path}`;
+  if (claim.field === OWNS) return [makeFinding(row.line, CODES.owns, message, row.id)];
+  if (claim.field !== SHARED) return [];
+  if (own && (record.path !== own.path || own.reachable.has(record.id) || record.reachable.has(own.id))) return [];
+  return [makeFinding(row.line, CODES.shared, `${message}; ${own ? ORDER_STORIES : NAME_STORY}`, row.id)];
+};
+
+const hasPinCover = (path, rows, facts, own) => posix.basename(path) === PIN_FILE && rows.some((row) => {
+  const fact = facts.pathFacts?.[row.path];
+  return PIN_VERBS.has(row.verb) && fact?.shipped === true && fact.pinTest === path && hasOwnCover(own, row.path);
+});
+const checkScope = (row, path, rows, facts, own) => {
+  if (!own || facts.pathFacts?.[path]?.inScope !== true || hasOwnCover(own, path) || hasPinCover(path, rows, facts, own)) return [];
+  return [makeFinding(row.line, CODES.scope,
+    `${row.id} path ${path} is in the declared practice and no claim of ${own.id} covers it`, row.id)];
+};
+
+export const checkStoryOwnership = ({ rows, goalLines, facts, getConcretePaths }) => {
+  const { story, findings } = readStoryLine(goalLines);
+  if (!Object.hasOwn(facts, STORY_FIELDS)) return { findings };
+  if (typeof facts.storeRefusal === STRING_TYPE) {
+    return sortFindings([...findings, makeFinding(FIRST_LINE, CODES.store, facts.storeRefusal)]);
+  }
+  const resolved = findOwnStory(story, facts);
+  const own = resolved.own;
+  const others = facts.stories.filter((record) => record.state !== LANDED && (!own || !hasIdentity(record, own)));
+  const validRows = rows.filter((row) => row.valid);
+  const relation = validRows.flatMap((row) => getConcretePaths(row, facts).flatMap((path) => [
+    ...others.flatMap((record) => record.claims.flatMap((claim) => checkCollision(row, path, record, claim, own))),
+    ...checkScope(row, path, validRows, facts, own),
+  ]));
+  return sortFindings([...findings, ...resolved.findings, ...relation]);
+};

package/tools/plan-shape.mjs

@@ -1,5 +1,8 @@
+import { posix } from 'node:path';
 import { tokenizeMarkdown } from '../references/scripts/markdown-blocks.mjs';
 import { parseRobustTag } from './robustness-literals.mjs';
+import { unique } from './claim-relation.mjs';
+import { checkStoryOwnership, PIN_FILE, PIN_VERBS } from './plan-shape-ownership.mjs';
 
 export const PLAN_TITLE_PREFIX = '# Plan: ';
 export const PLAN_HEADINGS = Object.freeze([
@@ -31,7 +34,7 @@ const BULLET = /^-\s+\S/;
 export const getLineCount = (text) => text === '' ? 0 : text.split('\n').length - (text.endsWith('\n') ? 1 : 0);
 export const isSweep = (path) => GLOB_BYTE.test(path);
 const endsWithPath = (path, suffix) => path === suffix || path.endsWith(`/${suffix}`);
-export const unique = (items) => [...new Set(items)];
+export { unique } from './claim-relation.mjs';
 const getFindingLine = (document, index) => document.frontLines + index + 1;
 const makeFinding = (line, code, message, rowId = null) => ({ line, code, message, rowId });
 const getHeading = (document, text) => document.headings.find((heading) => heading.text === text);
@@ -54,7 +57,8 @@ const getFigure = (value) => Number(String(value).replace(/^~/, ''));
 const getConcretePaths = (row, facts) => isSweep(row.path) ? facts.expansions?.[row.path] ?? [] : [row.path];
 const getPathFact = (facts, path) => facts.pathFacts?.[path] ?? null;
 const getAnchorPath = (anchor) => anchor.replace(/:[1-9]\d*$/, '');
-const hasPathDefect = (path) => path.startsWith('/') || path.includes('\\') || path.split('/').includes('..');
+const hasPathDefect = (path) => !(!path.includes('\\') &&
+  path.split('/').every((segment) => segment !== '' && segment !== '.' && segment !== '..'));
 const hasRaiseBullet = (verificationBullets, path) => verificationBullets.some((bullet) =>
   bullet.includes('--write-baseline') && bullet.includes('--reason') && bullet.includes(path));
 
@@ -174,6 +178,22 @@ const checkHeadings = (text, document) => {
   return findings;
 };
 
+const isPinRow = (row, path) => row.verb === 'modify' && row.path === path && posix.basename(row.path) === PIN_FILE;
+const checkPinBindings = (rows, owners, facts) => {
+  if (!Object.hasOwn(facts, 'pathFacts')) return [];
+  return [...owners].flatMap(([path, group]) => {
+    const pins = group.filter((row) => isPinRow(row, path));
+    if (pins.length < 2) return [];
+    const taken = new Set();
+    return pins.flatMap((pin) => {
+      const above = rows.slice(0, rows.indexOf(pin)).findLast((row) => row.valid && PIN_VERBS.has(row.verb) && !taken.has(row) &&
+        getPathFact(facts, row.path)?.shipped === true && getPathFact(facts, row.path)?.pinTest === path);
+      if (above) { taken.add(above); return []; }
+      return [makeFinding(pin.line, 'pin-unbound', `${pin.id} is a repeated pin row with no untaken shipped create or delete above it`, pin.id)];
+    });
+  });
+};
+
 const checkLedgerStructure = (parsed, facts) => {
   const findings = [];
   const nonBlank = parsed.entries.filter((entry) => entry.raw.trim() !== '');
@@ -206,11 +226,15 @@ const checkLedgerStructure = (parsed, facts) => {
   const owners = new Map();
   for (const row of parsed.rows.filter((item) => item.valid)) {
     for (const path of getConcretePaths(row, facts)) {
-      const prior = owners.get(path);
-      if (prior) findings.push(makeFinding(row.line, 'duplicate-path', `${path} is owned by both ${prior} and ${row.id}`, row.id));
-      else owners.set(path, row.id);
+      const prior = owners.get(path) ?? [];
+      const conflicting = prior.find((owner) => !isPinRow(owner, path) || !isPinRow(row, path));
+      if (conflicting) {
+        findings.push(makeFinding(row.line, 'duplicate-path', `${path} is owned by both ${conflicting.id} and ${row.id}`, row.id));
+      }
+      owners.set(path, [...prior, row]);
     }
   }
+  findings.push(...checkPinBindings(parsed.rows, owners, facts));
   const last = nonBlank.at(-1);
   if (!parsed.total || (parsed.totals ?? []).length !== 1 || last?.line !== parsed.total?.line) {
     findings.push(makeFinding(last?.line ?? 1, 'total', 'the exact total line must be the last non-blank ledger line'));
@@ -236,9 +260,9 @@ const getAnchorCandidates = (row, preceding, facts) => {
   return facts.candidates(suffix, precedingPaths);
 };
 
-const getCurrentLines = (rows, facts, verbs) => rows
+const getCurrentLines = (rows, facts, verbs) => unique(rows
   .filter((row) => row.valid && verbs.has(row.verb) && row.budget !== 'n/a')
-  .flatMap((row) => getConcretePaths(row, facts))
+  .flatMap((row) => getConcretePaths(row, facts)))
   .reduce((sum, path) => sum + (getPathFact(facts, path)?.lines ?? 0), 0);
 
 const checkAuthoring = (parsed, facts) => {
@@ -335,7 +359,11 @@ const judge = (text, facts, stateRules) => {
     return { findings: [makeFinding(line, 'block-model', parsedResult.error.message)], skips: [], parsed: null };
   }
   const parsed = parsedResult.parsed;
-  const structural = [...checkHeadings(String(text ?? ''), parsed.document), ...checkLedgerStructure(parsed, facts)];
+  const goal = getHeading(parsed.document, PLAN_HEADINGS[0]);
+  const goalLines = goal ? getSectionLines(parsed.document, PLAN_HEADINGS[0])
+    .map((text, offset) => ({ text, line: getFindingLine(parsed.document, goal.index + 1 + offset) })) : [];
+  const structural = [...checkHeadings(String(text ?? ''), parsed.document), ...checkLedgerStructure(parsed, facts),
+    ...checkStoryOwnership({ rows: parsed.rows, goalLines, facts, getConcretePaths }).findings];
   const state = stateRules ? stateRules(parsed, facts) : { findings: [], skips: [] };
   const findings = [...structural, ...state.findings].map((finding, index) => ({ ...finding, order: index }))
     .sort((left, right) => left.line - right.line || left.order - right.order)