simt-dev 0.6.3 → 0.7.1

package/src/plan/index.mjs

@@ -20,10 +20,11 @@
 // the file was read. Status and dependency checks never touch it: a 1 MB
 // section that belongs to a later slice is not copied into the index.
 
-import { readdir, readFile, writeFile } from 'node:fs/promises';
+import { readdir, readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 
 import { CLI } from '../name.mjs';
+import { commitJournal, journaledWriteFile } from '../journal.mjs';
 import { loadFormat } from './template.mjs';
 
 function clean(cell) {
@@ -100,10 +101,16 @@ function sliceKey(path, id) {
  * empty cell is the pipe that closes it. A further empty cell is real: the
  * evidence column is often blank, and stripping every trailing empty would
  * delete it and shift the state into the wrong column.
+ *
+ * A pipe inside a code span is content, not a separator: an evidence cell may
+ * carry a command line with a pipe in it, and splitting there shifts every
+ * later cell left by one (review 0003 Q25). Backticks toggle the span; a
+ * `\|` escape is content in either mode.
  */
 function splitRow(line) {
   const cells = [];
   let current = '';
+  let inCode = false;
   for (let i = 0; i < line.length; i += 1) {
     const char = line[i];
     if (char === '\\' && i + 1 < line.length) {
@@ -111,7 +118,12 @@ function splitRow(line) {
       i += 1;
       continue;
     }
-    if (char === '|') {
+    if (char === '`') {
+      inCode = !inCode;
+      current += char;
+      continue;
+    }
+    if (char === '|' && !inCode) {
       cells.push(current);
       current = '';
       continue;
@@ -596,9 +608,16 @@ export async function planDone(root, id, { sha = null, test = null, state = null
     return { root, id, error: `${id} is no longer on line ${slice.line} of ${slice.docName}`, remedy: `run: ${CLI} plan status` };
   }
 
-  const cells = splitRow(found.lines[found.index]);
-  const width = Math.max(slice.columnCount, slice.stateIdx + 1, slice.evidenceIdx + 1, cells.length);
-  while (cells.length < width) cells.push('');
+  const original = found.lines[found.index];
+  const cells = splitRow(original);
+  if (cells.length !== slice.columnCount) {
+    return {
+      root,
+      id,
+      error: `the row for ${id} has ${cells.length} cells; the table declares ${slice.columnCount}`,
+      remedy: `fix the row in ${slice.docName} — an unescaped pipe splits it — and retry`,
+    };
+  }
   const from = cells[slice.stateIdx] ?? '';
   cells[slice.stateIdx] = replaceState(from, display);
 
@@ -613,14 +632,18 @@ export async function planDone(root, id, { sha = null, test = null, state = null
     evidenceNote = 'no evidence column in this tracker; the sha was not recorded';
   }
 
-  const rebuilt = `| ${cells.join(' | ')} |`;
-  const original = found.lines[found.index];
+  // The rebuilt line keeps the original's ending: a CRLF file must not gain
+  // one LF-terminated line among its CRLF lines (review 0003 Q25).
+  const eol = original.endsWith('\r') ? '\r' : '';
+  const rebuilt = `| ${cells.join(' | ')} |${eol}`;
   const changedCells = splitRow(original).join('\0') !== cells.join('\0');
   const newLine = changedCells ? rebuilt : original;
   const wouldChange = newLine !== original;
   if (wouldChange && !dryRun) {
     found.lines[found.index] = newLine;
-    await writeFile(slice.docPath, found.lines.join('\n'), 'utf8');
+    const journal = [];
+    await journaledWriteFile(root, journal, slice.docPath, found.lines.join('\n'));
+    await commitJournal(root, 'plan', journal);
   }
 
   const apply = `run: ${CLI} plan done ${id}${sha ? ` ${sha}` : ''}${display === format.doneWrite ? '' : ` --state ${JSON.stringify(display)}`}${test ? ` --test ${JSON.stringify(test)}` : ''} --yes`;

package/src/plan/template.mjs

@@ -23,7 +23,7 @@ const KNOWN = new Set(['$comment', 'name', 'directories', 'id', 'columns', 'stat
 const ID_KEYS = new Set(['pattern', 'headers']);
 const COLUMN_KEYS = new Set(['state', 'depends', 'title', 'evidence']);
 const DIRECTORY_KEYS = new Set(['kind', 'word', 'path']);
-const STATE_KEYS = new Set(['id', 'write', 'read', 'satisfies']);
+const STATE_KEYS = new Set(['id', 'write', 'read', 'satisfies', 'role']);
 const DEPENDENCY_KEYS = new Set(['empty', 'separators', 'notes', 'group']);
 const WAVE_KEYS = new Set(['label', 'members']);
 const SECTION_KEYS = new Set(['depth']);
@@ -148,6 +148,7 @@ function compileStates(source, value) {
   const write = new Map();
   const known = new Set();
   const satisfies = new Set();
+  const roles = new Map();
   const order = [];
   const stateNames = [];
   for (let i = 0; i < value.length; i += 1) {
@@ -162,6 +163,13 @@ function compileStates(source, value) {
     }
     if (!Array.isArray(entry.read) || entry.read.length === 0) return bad(source, `${where}.read must list the words that mean this state`);
     if (known.has(entry.id)) return bad(source, `state ${entry.id} is listed twice`);
+    if (entry.role !== undefined && (typeof entry.role !== 'string' || !/^[a-z][a-z0-9-]*$/.test(entry.role))) {
+      return bad(source, `${where}.role must be a lower-case word`);
+    }
+    if (typeof entry.role === 'string') {
+      if (roles.has(entry.role)) return bad(source, `role ${entry.role} is claimed twice`);
+      roles.set(entry.role, entry.write.trim());
+    }
     const display = entry.write.trim();
     const aliases = new Set([entry.id, display.toLowerCase()]);
     for (const alias of entry.read) {
@@ -182,7 +190,7 @@ function compileStates(source, value) {
     else if (entry.satisfies != null && entry.satisfies !== false) return bad(source, `${where}.satisfies must be true or false`);
   }
   if (satisfies.size === 0) return bad(source, 'one state must have satisfies true, or nothing can ever be ready');
-  return { read, write, known, satisfies, order, stateNames };
+  return { read, write, known, satisfies, roles, order, stateNames };
 }
 
 function compile(body, source, root) {
@@ -262,7 +270,7 @@ function compile(body, source, root) {
 
   const byWord = new Map(directories.directories.map((dir) => [dir.word, dir.kind]));
   const doneWrite = body.states.find((entry) => entry.satisfies === true).write.trim();
-  const { read, write } = states;
+  const { read, write, roles } = states;
 
   return {
     format: {
@@ -273,6 +281,12 @@ function compile(body, source, root) {
       order: states.order,
       ready,
       doneWrite,
+      // The display a command moves a row to when work on it starts: the state
+      // carrying the `started` role, or null when no state claims it (review
+      // 0003 Q23). A null here is not an error — the caller falls back to the
+      // in-progress spelling it can read, and `plan done` fails closed on a
+      // word the template never defined.
+      startedWrite: roles.get('started') ?? null,
       stateNames: states.stateNames,
       satisfies: states.satisfies,
       known: states.known,
@@ -292,9 +306,17 @@ function compile(body, source, root) {
       headingRe: new RegExp(`^(#{1,${depth}})\\s+(.*\\S)\\s*$`),
       readState(raw) {
         const plain = String(raw ?? '').replace(/\*\*/g, '').trim().toLowerCase();
+        if (plain === '') return 'unknown';
         if (read.has(plain)) return read.get(plain);
-        const token = plain.split(/[\s(]/)[0];
-        return read.get(token) ?? (token || 'unknown');
+        // A cell may carry a note after the state — "In progress (since Monday)".
+        // The state is the longest alias that prefixes the text: "in progress"
+        // must win over a shorter alias it starts, and a word no state claims
+        // is unknown, not a state (review 0003 Q25).
+        let best = '';
+        for (const alias of read.keys()) {
+          if (alias.length > best.length && plain.startsWith(alias)) best = alias;
+        }
+        return best !== '' ? read.get(best) : 'unknown';
       },
       canonical(input) {
         return write.get(String(input ?? '').trim().toLowerCase()) ?? null;

package/src/plugins.mjs

@@ -32,7 +32,7 @@ import { desiredRegion } from './projection/rules.mjs';
 import { PACKAGE_NAME, BIN_REL } from './name.mjs';
 
 /** The kinds `simt plugin` builds, in the order the help line names them. */
-export const PLUGIN_KINDS = ['claude', 'gemini', 'cursor'];
+export const PLUGIN_KINDS = ['claude', 'gemini', 'cursor', 'opencode'];
 
 /**
  * The package this code ships in: the runtime a generated package copies. Resolved
@@ -71,7 +71,11 @@ function rootFlag(kind) {
 
 /** Where the hooks document lands inside a package, relative to the package root. */
 function hooksPath(kind) {
-  return kind === 'cursor' ? join('.cursor', 'hooks.json') : join('hooks', 'hooks.json');
+  if (kind === 'cursor') return join('.cursor', 'hooks.json');
+  // OpenCode loads a local plugin directory's root `server` file as the plugin, so the
+  // generated document is that file at the root rather than a hooks config to merge.
+  if (kind === 'opencode') return 'server.js';
+  return join('hooks', 'hooks.json');
 }
 
 const json = (value) => `${JSON.stringify(value, null, 2)}\n`;

package/src/prbody.mjs

@@ -21,11 +21,10 @@ import { readLedger, treeId } from './ledger/index.mjs';
 import { readCheckCache } from './status.mjs';
 import { readManifest } from './projection/manifest.mjs';
 import { splitFrontmatter } from './memory/decide.mjs';
+import { decisionsDir } from './decisions/dir.mjs';
 
 const exec = promisify(execFile);
 
-const DECISIONS_DIR = join('docs', 'decisions');
-
 /**
  * The ref the body diffs against: the override when given, else the first
  * candidate that shares history with HEAD. Returns the ref, or null when the
@@ -98,15 +97,18 @@ async function changedPaths(root, base) {
  * reported with what it has rather than dropping the row.
  */
 async function changedDecisions(root, paths) {
-  const names = paths.filter((p) => p.startsWith(`${DECISIONS_DIR}/`) && p.toLowerCase().endsWith('.md'));
+  // Q55: the prefix is the repository's own decisions directory, not a literal.
+  const relDir = await decisionsDir(root);
+  const absDir = join(root, relDir);
+  const names = paths.filter((p) => p.startsWith(`${relDir}/`) && p.toLowerCase().endsWith('.md'));
   try {
-    await readdir(join(root, DECISIONS_DIR));
+    await readdir(absDir);
   } catch {
     return [];
   }
   const out = [];
   for (const name of names.sort()) {
-    const id = /^ADR-\d{3,}/i.exec(name.slice(DECISIONS_DIR.length + 1))?.[0].toUpperCase() ?? name;
+    const id = /^ADR-\d{3,}/i.exec(name.slice(relDir.length + 1))?.[0].toUpperCase() ?? name;
     let title = id;
     let status = 'unknown';
     try {

package/src/projection/baselines.mjs

@@ -76,7 +76,7 @@ trim_trailing_whitespace = false
 indent_style = space
 indent_size = 2
 
-[*.{py,pyi,java,kt,kts}]
+[*.{py,pyi,java,kt,kts,rs}]
 indent_size = 4
 
 [{Makefile,*.mk}]

package/src/projection/disclosure.mjs

@@ -25,7 +25,7 @@ const SKILL_DIRS = ['.agents/skills', '.cursor/skills', '.claude/skills', '.open
  * share a name both stay, because dropping one would hide a trigger.
  *
  * @param {string} root
- * @returns {Promise<{name: string, trigger: string, dir: string}[]>}
+ * @returns {Promise<{name: string, trigger: string, dir: string, file: string}[]>}
  */
 export async function installedSkills(root) {
   const seen = new Set();
@@ -61,7 +61,7 @@ export async function installedSkills(root) {
       const fallback = entry.isDirectory() ? entry.name : entry.name.replace(/\.md$/, '');
       const name = typeof meta.name === 'string' && meta.name !== '' ? meta.name : fallback;
       const trigger = typeof meta.description === 'string' ? meta.description.replace(/\s+/g, ' ').trim() : '';
-      skills.push({ name, trigger, dir });
+      skills.push({ name, trigger, dir, file: key });
     }
   }
   skills.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : a.dir < b.dir ? -1 : a.dir > b.dir ? 1 : 0));

package/src/projection/loaders.mjs

@@ -146,10 +146,16 @@ export const LOADERS = [
     nested: 'cumulative up to the project root at session start; files below the workspace load when that area is read',
     skills: ['.agents/skills', '.opencode/skills', '.claude/skills'],
     hooks: {
-      path: '.opencode/plugins/',
+      path: '.opencode/plugins/simt-dev.js',
       verified:
         'OpenCode v2 plugins docs: direct .ts and .js files and immediate plugin packages are loaded from every discovered .opencode/plugins/ directory, and the plugins array in opencode.json(c)',
     },
+    agents: {
+      dir: '.opencode/agents',
+      ext: '.md',
+      verified:
+        'OpenCode v2 agents docs (opencode.ai/v2/docs/agents, read 2026-10-30): subagents are markdown files with a description frontmatter under .opencode/agents/',
+    },
     mcp: {
       path: 'opencode.json',
       key: 'mcp.servers',
@@ -242,6 +248,12 @@ export const LOADERS = [
       verified:
         'Claude Code hooks docs, hook locations: project settings at .claude/settings.json and .claude/settings.local.json, user settings at ~/.claude/settings.json',
     },
+    agents: {
+      dir: '.claude/agents',
+      ext: '.md',
+      verified:
+        'Claude Code subagents docs (code.claude.com/docs/en/sub-agents, read 2026-10-30): project subagents are markdown files with name and description frontmatter under .claude/agents/',
+    },
     mcp: {
       path: '.mcp.json',
       key: null,
@@ -320,6 +332,12 @@ export const LOADERS = [
       verified:
         'Codex hooks docs: <repo>/.codex/hooks.json or ~/.codex/hooks.json, or inline [hooks] tables in config.toml',
     },
+    agents: {
+      dir: '.codex/agents',
+      ext: '.toml',
+      verified:
+        'Codex custom agents docs (developers.openai.com/codex/subagents, read 2026-10-30): standalone TOML files under .codex/agents/ defining name, description and developer_instructions',
+    },
     mcp: {
       path: '.codex/config.toml',
       key: 'mcp_servers',
@@ -386,6 +404,12 @@ export const LOADERS = [
       path: '.cursor/hooks.json',
       verified: 'Cursor agent hooks docs: <project-root>/.cursor/hooks.json and ~/.cursor/hooks.json',
     },
+    agents: {
+      dir: '.cursor/agents',
+      ext: '.md',
+      verified:
+        'Cursor subagents docs (cursor.com/docs/subagents, read 2026-10-30): project subagents are markdown files with name and description frontmatter under .cursor/agents/',
+    },
     mcp: {
       path: '.cursor/mcp.json',
       key: null,
@@ -470,6 +494,12 @@ export const LOADERS = [
       path: '.agents/hooks.json',
       verified: 'Antigravity hooks docs: workspace level .agents/hooks.json, global ~/.gemini/config/hooks.json',
     },
+    agents: {
+      dir: '.agents/agents',
+      ext: '.md',
+      verified:
+        'Google Antigravity subagents docs (antigravity.google/docs/subagents, read 2026-10-30): project subagents are markdown files with name and description frontmatter under .agents/agents/',
+    },
     mcp: {
       path: '.agents/mcp_config.json',
       key: null,
@@ -541,6 +571,12 @@ export const LOADERS = [
       verified:
         'Gemini CLI hooks reference (geminicli.com/docs/hooks/reference/, read 2026-10-26): a project .gemini/settings.json carries a top-level hooks object whose events are arrays of {matcher, hooks:[{type:"command",command,timeout? (milliseconds)}]} — the same shape Claude and Codex use; BeforeTool denies with {decision:"deny",reason}, BeforeAgent and AfterTool inject via hookSpecificOutput.additionalContext',
     },
+    agents: {
+      dir: '.gemini/agents',
+      ext: '.md',
+      verified:
+        'Gemini CLI subagents docs (geminicli.com/docs/core/subagents, read 2026-10-30): project subagents are markdown files with name and description frontmatter under .gemini/agents/',
+    },
     mcp: {
       path: '.gemini/settings.json',
       key: 'mcpServers',
@@ -603,6 +639,8 @@ export const LOADERS = [
     skillsNote: 'no project skill directory is documented for Copilot',
     hooks: null,
     hooksNote: 'no hooks file is documented for Copilot in any first-party page checked on 2026-10-14',
+    agents: null,
+    agentsNote: 'no file-based agents are documented for Copilot in any first-party page checked on 2026-10-30',
     mcp: {
       path: '.vscode/mcp.json',
       key: null,
@@ -707,6 +745,8 @@ export const LOADERS = [
     hooks: null,
     hooksNote:
       'DeepSeek harness hooks docs: the Claude Code and Codex bridges take an explicit configPath, and project-local hooks.json discovery is still marked TODO, so no repository path is loaded by default',
+    agents: null,
+    agentsNote: 'no file-based agents are documented for the DeepSeek harness in any first-party page checked on 2026-10-30',
     mcp: {
       path: null,
       key: '@deepseek-ai/dsh-mcp-client',

package/src/projection/lock.mjs

@@ -13,10 +13,14 @@ import { join } from 'node:path';
 
 import { readLockedVariants } from '../kernel/variants.mjs';
 import { fingerprint } from '../resolve/fingerprint.mjs';
+import { LOCK_FILE, LOCK_LEGACY } from '../name.mjs';
 import { desiredRegion, provenanceDigest, LOCAL_PROFILE_DIR } from './rules.mjs';
 import { readManifest } from './manifest.mjs';
 
-export const LOCK_FILE = 'simt-dev.lock.json';
+/** The lock's own format. Bumped only when a reader must interpret an old file
+ *  differently; an absent field means 1, because every lock written before this
+ *  field existed was written by the only format there has been. */
+const LOCK_VERSION = 1;
 
 /** Manifest keys that change what the region contains. Anything else in the file is
  *  the repository's own notes, and hashing it would make a comment fail the lock. */
@@ -28,20 +32,23 @@ const MANIFEST_KEYS = ['mode', 'budget', 'shared', 'surfaces', 'gates'];
  * @param {string} root
  * @param {object} [flags] the same flags `sync` rendered with, so the output is the
  *   body that was written and not a body for a different set of surfaces
+ * @param {object} [manifest] the manifest to digest, in place of the one on disk. A
+ *   writer that is about to write a manifest (a fresh `init`) passes it here so the
+ *   lock records the state the repo will have, not the state it has (Q29).
  */
-export async function computeLock(root, flags = {}) {
+export async function computeLock(root, flags = {}, manifest = undefined) {
   const variants =
     flags?.variants !== undefined ? flags.variants : await readLockedVariants(root);
   const desired = await desiredRegion(root, { ...flags, variants });
-  const inputs = await inputDigest(root, variants);
+  const inputs = await inputDigest(root, variants, manifest);
   const outputs = createHash('sha256').update(desired.body).digest('hex');
   const hasVariants =
     variants && typeof variants === 'object' && Object.keys(variants).length > 0;
-  return hasVariants ? { inputs, outputs, variants } : { inputs, outputs };
+  return hasVariants ? { version: LOCK_VERSION, inputs, outputs, variants } : { version: LOCK_VERSION, inputs, outputs };
 }
 
 /**
- * Record locked variant winners in `simt-dev.lock.json` alongside updated digests.
+ * Record locked variant winners in `simt.lock.json` alongside updated digests.
  */
 export async function writeLockVariants(root, nextVariants, flags = {}) {
   const existing = await readLockedVariants(root);
@@ -53,17 +60,27 @@ export async function writeLockVariants(root, nextVariants, flags = {}) {
 
 /** Read a lock, or null when the file is not there. A file that does not parse is an
  *  error the caller reports, not a missing lock: absence and damage are different
- *  repairs. */
+ *  repairs. A lock under the legacy name is a lock (ADR-110): it is read until the
+ *  next write migrates it, and a permission failure on the new name is not an excuse
+ *  to fall back to an older file. */
 export async function readLock(root) {
-  let text;
-  try {
-    text = await readFile(join(root, LOCK_FILE), 'utf8');
-  } catch (error) {
-    if (error.code === 'ENOENT') return { lock: null, error: null };
-    throw error;
+  let text = null;
+  for (const name of [LOCK_FILE, LOCK_LEGACY]) {
+    try {
+      text = await readFile(join(root, name), 'utf8');
+      break;
+    } catch (error) {
+      if (error.code !== 'ENOENT') throw error;
+    }
   }
+  if (text === null) return { lock: null, error: null };
   try {
     const lock = JSON.parse(text);
+    // Absent means 1; a version this build does not know is a lock it cannot judge,
+    // and reading it anyway would report drift for a format change.
+    if (lock.version !== undefined && (!Number.isInteger(lock.version) || lock.version < 1)) {
+      return { lock: null, error: 'version must be an integer of at least 1' };
+    }
     if (typeof lock?.inputs !== 'string' || typeof lock?.outputs !== 'string') {
       return { lock: null, error: 'must be an object with inputs and outputs' };
     }
@@ -79,13 +96,13 @@ export async function readLock(root) {
   }
 }
 
-async function inputDigest(root, variants = {}) {
+async function inputDigest(root, variants = {}, manifest = undefined) {
   const hash = createHash('sha256');
   hash.update(`provenance:${await provenanceDigest()}\n`);
   const { stack, facts } = await fingerprint(root);
   hash.update(`signals:${JSON.stringify({ stack, facts })}\n`);
-  const { manifest } = await readManifest(root);
   const owned = {};
+  if (manifest === undefined) manifest = (await readManifest(root)).manifest;
   if (manifest && typeof manifest === 'object') {
     for (const key of MANIFEST_KEYS) {
       if (manifest[key] !== undefined) owned[key] = manifest[key];