ll-skills 2.0.2 → 3.0.0

package/skills/ll-auto/references/run.md

@@ -0,0 +1,75 @@
+# The run — `docs/AUTO.md`, decisions, end block
+
+## The file
+
+`ll-auto.js auto-md --objective "<objective>" --flags "<the arguments>"` prints the body; step 1
+redirects it to `docs/AUTO.md`. Five sections, no frontmatter:
+
+```
+# AUTO — autonomous run
+
+## Objective
+
+<the objective, on its own line>
+
+## Flags
+
+<the flags string, on its own line>
+
+## Roteiro
+
+| # | stage | command | status | evidence |
+|---|---|---|---|---|
+| 1 | phase-08 | ll-implement 08 --no-talk | todo | ROADMAP row: PLANNED |
+
+## Decisions taken alone
+
+(filled at the end of the run)
+
+## Log
+
+(one dated line per stage transition)
+```
+
+Status of a row: `todo` · `half` · `running` · `done` · `skipped` · `waiting`. Exactly one row is
+`running` at a time. The `evidence` column is the one `detect` gave for that stage, refreshed when
+the row is marked `done` or `half`.
+
+A log line is `<YYYY-MM-DD HH:MM> <stage> <status> — <evidence or the stage's last line>`, appended,
+never rewritten. The `## Flags` section is what `--resume` reads, so it is written once and left
+alone; a run restarted with different flags rewrites the whole file.
+
+## Decisions only the owner can take
+
+After every stage, list the `decisions/*.md` whose status is `WAITING`.
+
+Without `--auto-decision`:
+- the run continues through the stages that do not depend on them; a phase whose ROADMAP section
+  carries `stop: owner` is skipped and its row is marked `skipped`;
+- the rows that depend on a WAITING decision are marked `waiting`;
+- when nothing else can run, print the WAITING list — one line per file, with the question and the
+  recommended option — and stop with `▶ Next — /clear, then ll-auto --resume`.
+
+With `--auto-decision`:
+- append to each WAITING decision file a dated line
+  `status: DECIDED — <the recommended option> [decided by absence — revisable]`;
+- clear the `stop: owner` marks those decisions held in ROADMAP;
+- continue the roteiro; the marker is what the end block lists.
+
+Nothing is decided outside these two paths: a decision that has no recommended option stays
+`WAITING` and stops the run even under `--auto-decision`, because there is nothing to pick.
+
+## The end block
+
+`ll-auto.js report --json` answers `{"decisions":[{file, title, line}]}` for every `decisions/*.md`
+carrying `[decided by absence — revisable]`. Print it, and write the same lines into the
+`## Decisions taken alone` section:
+
+```
+Decisions taken alone — review them:
+- decisions/DEC-0007-retry-policy.md — retry policy for the provider adapter (line 12)
+- decisions/DEC-0009-report-window.md — the window the report counts (line 9)
+```
+
+An empty list is printed as `Decisions taken alone: none`. Then the count line of the Completion
+criterion, then the handover. The run ends there: the next command belongs to the owner.

package/skills/ll-auto/references/stages.md

@@ -0,0 +1,66 @@
+# Stages — detection, commands, flags
+
+## Detection
+
+`ll-auto.js detect` reads only the files below and is deterministic: the same tree gives the same
+table twice. Every entry answers `{id, status, evidence}` with status `todo`, `half` or `done`.
+
+| stage | done when | half when | evidence field |
+|---|---|---|---|
+| `research` | a `docs/research-*/SUMMARY.md` exists | never | the path, or what is missing |
+| `brainstorm` | `docs/decide/OPENING.md` or any `phases/NN/DECISIONS.md` exists | never | the path, or what is missing |
+| `decide` | `PLAN.md` at the root and `PROGRESS.md` with an `ll-state` block | never | `PLAN.md + PROGRESS.md ll-state block` |
+| `phase-NN` | the ROADMAP row state starts with `DONE`, or `## Epilogue — phase NN` exists over a board that is for another phase or all `passes: true` | `phases/NN/PLAN.md` exists and the phase is not done | the ROADMAP row, or the epilogue and the milestones still red |
+| `verify-NN` | `phases/NN/VERIFICATION.md` exists | never | the path, or what is missing |
+| `close` | `docs/DELIVERY.md` exists and the last ROADMAP phase has an epilogue | never | the path, or what is missing |
+
+One `phase-NN` per row of the ROADMAP table; with no ROADMAP.md, the phases come from the same
+table inline at `PLAN.md` §8, same columns (`| phase | name | depends_on | requirements | state |`);
+with no `PLAN.md`, none. One `verify-NN` per phase row. `close` is always last.
+
+A phase with an epilogue over a board that still shows a milestone `passes: false` is `half`, not
+`done`: the epilogue was written, the phase was not finished. `ll-implement NN` resumes it from the
+board, which is why a `half` phase enters the roteiro with the same command as a `todo` one.
+
+## The command per stage
+
+| stage | command | note |
+|---|---|---|
+| `research` | `ll-research "<objective>"` | only with `--research`; the objective is the run's |
+| `brainstorm` | `ll-brainstorm project --no-talk` | only with `--brainstorm`; `--interactive` drops `--no-talk` |
+| `decide` | `ll-decide project --no-talk` | enters whenever it is `todo` |
+| `phase-NN` | `ll-implement NN --no-talk` | `--interactive` drops `--no-talk`; a `half` phase resumes with the same command |
+| `verify-NN` | `ll-verify NN` | never `--external`: that flag hands the audit to another session, which this run is not |
+| `close` | `ll-close --no-talk` | `--milestone <name>` when the ROADMAP is complete |
+
+The number is written as the ROADMAP writes it (`08`, not `8`). The roteiro entry carries the
+command ready to follow; the stage's own skill decides everything inside it.
+
+## Which stages enter the roteiro
+
+`research` and `brainstorm` enter only when their flag is set and their status is not `done`.
+`decide` enters when it is `todo`. Every phase row that is not `done` enters, filtered by
+`--from/--to/--only`, the `half` ones first as a resume. `verify-NN` enters right after its phase
+when `--verify all` is set or when the phase's epilogue names `ll-verify NN` in its handover line.
+`close` enters last, unless `--only` or `--to` cut the roteiro before the last row.
+
+## Flags
+
+| flag | effect |
+|---|---|
+| `"<objective>"` | the run's objective: the argument of `ll-research`, and the `## Objective` of `docs/AUTO.md` |
+| `--research` | put `research` in the roteiro when it is not done |
+| `--brainstorm` | put `brainstorm` in the roteiro when it is not done |
+| `--interactive` | drop `--no-talk` from `ll-brainstorm` and `ll-implement`: those stages talk to the owner |
+| `--auto-decision` | resolve every owner-only decision to its recommended option and continue; without it the run stops when one blocks the way |
+| `--pause-at <stage\|N>` | stop after that stage or phase, with `▶ Next — /clear, then ll-auto --resume` |
+| `--from N` | skip the phase rows below N |
+| `--to N` | skip the phase rows above N |
+| `--only N` | phase N alone; implies `--from N --to N` and cuts `close` |
+| `--verify all` | a `verify-NN` after every phase, whatever the epilogue says |
+| `--redo <stage>` | force a `done` stage back to `todo` in the roteiro; repeatable |
+| `--dry-run` | print the roteiro table and stop, before writing `docs/AUTO.md` |
+| `--resume` | read the flags from the `## Flags` section of `docs/AUTO.md` and continue from the first row that is not `done` |
+
+`--pause-at` and `--redo` are repeatable. A plain invocation in a repository that already carries
+`docs/AUTO.md` behaves as `--resume`: the flags of the file are the flags of the run.

package/skills/ll-auto/scripts/ll-auto.js

@@ -0,0 +1,345 @@
+#!/usr/bin/env node
+// ll-auto helper — reads the cycle state from disk. Self-contained: `fs` and `path` only.
+// Read commands never fail: on a broken input they print {"ok":false,"reason":…} and exit 0.
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const J = path.join;
+function readText(f) { try { return fs.readFileSync(f, 'utf8'); } catch { return null; } }
+function isDir(p) { try { return fs.statSync(p).isDirectory(); } catch { return false; } }
+function exists(p) { try { fs.statSync(p); return true; } catch { return false; } }
+function ls(d) { try { return fs.readdirSync(d).sort(); } catch { return []; } }
+function nn(v) { return String(v).trim().padStart(2, '0'); }
+
+// --- state block reader, copied from scripts/ll-tools.js (<ll-shared:state>) -----------------
+function readAnchoredBlock(file, name) {
+  let txt;
+  try { txt = fs.readFileSync(file, 'utf8'); } catch { return null; }
+  const all = txt.split('\n');
+  const open = new RegExp('^<!--\\s*' + name + '\\s*-->\\s*$');
+  const close = new RegExp('^<!--\\s*/' + name + '\\s*-->\\s*$');
+  let start = -1, end = -1;
+  for (let i = 0; i < all.length; i++) {
+    if (start < 0) { if (open.test(all[i])) start = i; } else if (close.test(all[i])) { end = i; break; }
+  }
+  if (start < 0 || end < 0) return null;
+  return { file, start, end, all, lines: all.slice(start + 1, end) };
+}
+function llSplitFlow(str) { // top-level commas only
+  const out = [];
+  let cur = '', depth = 0, q = null;
+  for (const ch of str) {
+    if (q) { cur += ch; if (ch === q) q = null; continue; }
+    if (ch === '"' || ch === "'") { q = ch; cur += ch; continue; }
+    if (ch === '[' || ch === '{') depth++;
+    else if (ch === ']' || ch === '}') depth--;
+    else if (ch === ',' && depth === 0) { out.push(cur); cur = ''; continue; }
+    cur += ch;
+  }
+  if (cur.trim() !== '') out.push(cur);
+  return out;
+}
+function llScalar(raw) {
+  const s = String(raw).trim();
+  if (/^\[[\s\S]*\]$/.test(s)) return llSplitFlow(s.slice(1, -1)).map(llScalar);
+  if (/^\{[\s\S]*\}$/.test(s)) {
+    const o = {};
+    for (const part of llSplitFlow(s.slice(1, -1))) {
+      const m = /^\s*([A-Za-z_][\w-]*)\s*:\s*([\s\S]*)$/.exec(part);
+      if (m) o[m[1]] = llScalar(m[2]);
+    }
+    return o;
+  }
+  if (/^(true|yes)$/i.test(s)) return true;
+  if (/^(false|no)$/i.test(s)) return false;
+  if (/^".*"$/.test(s) || /^'.*'$/.test(s)) return s.slice(1, -1);
+  return s;
+}
+function parseStateBlockLite(bl) {
+  const st = { phase: null, milestones: {}, order: [] };
+  let inM = false;
+  for (let i = 0; i < bl.length; i++) {
+    const line = bl[i].replace(/\s+$/, '');
+    if (!line.trim() || /^\s*#/.test(line)) continue;
+    let m = /^phase:\s*(.*)$/.exec(line);
+    if (m) { st.phase = String(llScalar(m[1])); inM = false; continue; }
+    if (/^milestones:\s*(\{\s*\})?$/.test(line)) { inM = true; continue; }
+    m = /^(\s*)(M\d+|G-\d+):\s*\{(.*)\}\s*$/.exec(line);
+    if (m && inM) {
+      st.milestones[m[2]] = llScalar('{' + m[3] + '}');
+      st.order.push({ id: m[2], index: i, indent: m[1] });
+    } else if (/^\S/.test(line)) inM = false;
+  }
+  return st;
+}
+
+// --- phase rows ------------------------------------------------------------------------------
+// Rows of the ROADMAP phase table: a header carrying `phase` and numeric first cells.
+function phaseRows(md) {
+  const rows = [], seen = new Set();
+  let cols = null;
+  for (const line of String(md || '').split('\n')) {
+    if (!/^\s*\|/.test(line)) { cols = null; continue; }
+    const cells = line.trim().replace(/^\|/, '').replace(/\|$/, '').split('|').map((c) => c.trim());
+    if (/^:?-{2,}/.test(cells[0] || '')) continue; // separator row
+    if (!/^\d{1,3}$/.test(cells[0] || '')) { cols = cells.map((c) => c.toLowerCase()); continue; }
+    if (!cols || cols.indexOf('phase') < 0) continue;
+    const i = cols.indexOf('state');
+    const id = nn(cells[0]);
+    if (seen.has(id)) continue;
+    seen.add(id);
+    rows.push({ nn: id, state: (i >= 0 ? cells[i] : cells[cells.length - 1]) || '' });
+  }
+  return rows;
+}
+// Without ROADMAP.md the rows live in the `## §8 Phases` table of PLAN.md (`| NN | name | … |`,
+// a header cell `phase` and, when there is one, a `state` cell); without PLAN.md there are no
+// phases at all. The §8 slice runs to the next `## ` heading — `$` under /m ends at every line.
+function rowsOf(root) {
+  const rm = readText(J(root, 'ROADMAP.md'));
+  if (rm !== null) return phaseRows(rm);
+  const plan = readText(J(root, 'PLAN.md'));
+  if (plan === null) return [];
+  const h = /^##\s*§?8\b[^\n]*\n/m.exec(plan);
+  if (!h) return [];
+  const rest = plan.slice(h.index + h[0].length);
+  const next = rest.search(/^##\s/m);
+  return phaseRows(next < 0 ? rest : rest.slice(0, next));
+}
+
+// --- detect ----------------------------------------------------------------------------------
+function phaseStage(root, row, ctx) {
+  if (/^DONE/.test(row.state)) return { status: 'done', evidence: 'ROADMAP row: ' + row.state };
+  const plan = 'phases/' + row.nn + '/PLAN.md';
+  if (ctx.epilogues.has(row.nn)) {
+    const own = ctx.state && nn(ctx.state.phase || '') === row.nn;
+    const red = own ? Object.keys(ctx.state.milestones).filter((k) => ctx.state.milestones[k].passes !== true) : [];
+    if (!own || red.length === 0) return { status: 'done', evidence: 'PROGRESS.md: ## Epilogue — phase ' + row.nn };
+    if (exists(J(root, 'phases', row.nn, 'PLAN.md'))) {
+      return { status: 'half', evidence: 'epilogue over a board with ' + red.join(', ') + ' not passing' };
+    }
+  }
+  if (exists(J(root, 'phases', row.nn, 'PLAN.md'))) return { status: 'half', evidence: plan };
+  return { status: 'todo', evidence: 'ROADMAP row: ' + (row.state || '-') };
+}
+
+function detect(root) {
+  const stages = [];
+  const add = (id, status, evidence) => stages.push({ id, status, evidence });
+  const research = ls(J(root, 'docs')).filter((n) => /^research-/.test(n) && exists(J(root, 'docs', n, 'SUMMARY.md')));
+  add('research', research.length ? 'done' : 'todo',
+    research.length ? 'docs/' + research[0] + '/SUMMARY.md' : 'no docs/research-*/SUMMARY.md');
+
+  const opening = exists(J(root, 'docs', 'decide', 'OPENING.md'));
+  const decided = ls(J(root, 'phases')).filter((n) => exists(J(root, 'phases', n, 'DECISIONS.md')));
+  add('brainstorm', opening || decided.length ? 'done' : 'todo',
+    opening ? 'docs/decide/OPENING.md'
+      : decided.length ? 'phases/' + decided[0] + '/DECISIONS.md' : 'no docs/decide/OPENING.md');
+
+  const progress = J(root, 'PROGRESS.md');
+  const block = readAnchoredBlock(progress, 'll-state');
+  const state = block ? parseStateBlockLite(block.lines) : null;
+  const hasPlan = exists(J(root, 'PLAN.md'));
+  add('decide', hasPlan && state ? 'done' : 'todo',
+    hasPlan && state ? 'PLAN.md + PROGRESS.md ll-state block'
+      : hasPlan ? 'PROGRESS.md carries no ll-state block' : 'no PLAN.md at the root');
+  const epilogues = new Set();
+  for (const line of (readText(progress) || '').split('\n')) {
+    const h = /^## Epilogue — phase (\S+)/.exec(line);
+    if (h) epilogues.add(nn(h[1]));
+  }
+  const rows = rowsOf(root);
+  const ctx = { epilogues, state };
+  for (const row of rows) {
+    const s = phaseStage(root, row, ctx);
+    add('phase-' + row.nn, s.status, s.evidence);
+  }
+  for (const row of rows) {
+    const v = 'phases/' + row.nn + '/VERIFICATION.md';
+    const ok = exists(J(root, v));
+    add('verify-' + row.nn, ok ? 'done' : 'todo', ok ? v : 'no ' + v);
+  }
+  const last = rows.length ? rows[rows.length - 1].nn : null;
+  const delivery = exists(J(root, 'docs', 'DELIVERY.md'));
+  const closed = delivery && last !== null && epilogues.has(last);
+  add('close', closed ? 'done' : 'todo',
+    closed ? 'docs/DELIVERY.md + epilogue for phase ' + last
+      : delivery ? 'docs/DELIVERY.md without an epilogue for the last phase' : 'no docs/DELIVERY.md');
+  return { ok: true, root, stages };
+}
+
+// --- next-cmd --------------------------------------------------------------------------------
+// The handoff grammar of lint-contract rule 6: `▶ Next — /clear, then <cmd> (alternatives)`.
+// Backticks are decoration; one trailing parenthetical is dropped. The last line in the file wins.
+function nextCmdOf(txt) {
+  let out = '';
+  for (const line of String(txt || '').split('\n')) {
+    const m = /▶ Next\s*—(.*)$/.exec(line);
+    if (!m) continue;
+    const hand = m[1].replace(/`/g, '').trim();
+    const o = /^\/clear\s*,\s*then\s+(.*)$/.exec(hand);
+    if (o) out = o[1].replace(/\([^()]*\)\s*$/, '').trim();
+  }
+  return out;
+}
+// The slice of PROGRESS.md owned by phase NN's epilogue; the whole file when it has none.
+function epilogueText(root, id) {
+  const txt = readText(J(root, 'PROGRESS.md')) || '';
+  const lines = txt.split('\n');
+  let start = -1;
+  for (let i = 0; i < lines.length; i++) {
+    const h = /^## Epilogue — phase (\S+)/.exec(lines[i]);
+    if (h && nn(h[1]) === id) start = i;
+  }
+  if (start < 0) return txt;
+  let end = lines.length;
+  for (let i = start + 1; i < lines.length; i++) if (/^## /.test(lines[i])) { end = i; break; }
+  return lines.slice(start, end).join('\n');
+}
+
+// --- roteiro ---------------------------------------------------------------------------------
+const FLAG_ONE = { '--research': 'research', '--brainstorm': 'brainstorm', '--interactive': 'interactive',
+  '--auto-decision': 'auto_decision', '--dry-run': 'dry_run', '--resume': 'resume' };
+const FLAG_VAL = { '--pause-at': 'pause_at', '--redo': 'redo', '--from': 'from', '--to': 'to',
+  '--only': 'only', '--verify': 'verify' };
+// A stage reference in --pause-at / --redo: an id, a bare phase number, or `phase 7`.
+function stageId(x) {
+  const s = String(x || '').trim();
+  if (/^\d{1,3}$/.test(s)) return 'phase-' + nn(s);
+  const m = /^(phase|verify)[\s-]*(\d{1,3})$/.exec(s);
+  return m ? m[1] + '-' + nn(m[2]) : s;
+}
+function parseFlags(str) {
+  const f = { pause_at: [], redo: [], from: null, to: null, only: null, verify: null };
+  for (const k of Object.values(FLAG_ONE)) f[k] = false;
+  const t = String(str || '').trim().split(/\s+/).filter(Boolean);
+  for (let i = 0; i < t.length; i++) {
+    if (FLAG_ONE[t[i]]) { f[FLAG_ONE[t[i]]] = true; continue; }
+    const k = FLAG_VAL[t[i]];
+    if (!k) continue;
+    const v = i + 1 < t.length && !/^--/.test(t[i + 1]) ? t[++i] : null;
+    if (k === 'pause_at' || k === 'redo') { if (v !== null) f[k].push(v); } else f[k] = v;
+  }
+  if (f.only !== null) { f.from = f.only; f.to = f.only; } // --only N implies from = to = N
+  return f;
+}
+const num = (x) => Number(String(x).replace(/[^\d.]/g, '')) || 0;
+const talk = (interactive) => (interactive ? '' : ' --no-talk'); // --interactive drops --no-talk
+
+function roteiro(root, flagStr, objective) {
+  const d = detect(root);
+  const f = parseFlags(flagStr);
+  const st = {};
+  for (const s of d.stages) st[s.id] = s;
+  const redo = new Set(f.redo.map(stageId));
+  const pause = new Set(f.pause_at.map(stageId));
+  const obj = String(objective || '').trim();
+  // Empty repository per D-03-06: no research, no OPENING.md, no PLAN.md.
+  const bare = st.research.status === 'todo' && st.brainstorm.status === 'todo' && !exists(J(root, 'PLAN.md'));
+  if (bare && !obj) return { ok: true, root, needs_objective: true, roteiro: [] };
+  const out = [];
+  const want = (id) => redo.has(id) || !st[id] || st[id].status !== 'done';
+  const push = (id, command) => out.push({ stage: id, command,
+    status: st[id] ? st[id].status : 'todo', pause_after: pause.has(id) });
+  if (f.research && want('research')) push('research', 'll-research "' + (obj || '<objective>') + '"');
+  if (f.brainstorm && want('brainstorm')) push('brainstorm', 'll-brainstorm project' + talk(f.interactive));
+  if (want('decide')) push('decide', 'll-decide project --no-talk');
+  const rows = rowsOf(root);
+  const pend = rows.filter((r) => want('phase-' + r.nn));
+  const inRange = (r) => (f.from === null || num(r.nn) >= num(f.from))
+    && (f.to === null || num(r.nn) <= num(f.to));
+  const kept = pend.filter(inRange);
+  const half = (r) => st['phase-' + r.nn].status === 'half';
+  for (const r of kept.filter(half).concat(kept.filter((r) => !half(r)))) { // a half phase resumes first
+    push('phase-' + r.nn, 'll-implement ' + r.nn + talk(f.interactive));
+    const asked = new RegExp('^ll-verify\\s+0*' + num(r.nn) + '$').test(nextCmdOf(epilogueText(root, r.nn)));
+    if ((f.verify === 'all' || asked) && want('verify-' + r.nn)) push('verify-' + r.nn, 'll-verify ' + r.nn);
+  }
+  // Close only when the roteiro covers every phase still open: --only, --from or --to cut it out.
+  if (f.only === null && kept.length === pend.length && want('close')) push('close', 'll-close --no-talk');
+  return { ok: true, root, needs_objective: false, roteiro: out };
+}
+
+// --- report ----------------------------------------------------------------------------------
+const MARK = '[decided by absence — revisable]';
+function report(root) {
+  const dir = J(root, 'decisions'), out = [];
+  for (const name of ls(dir)) {
+    if (!/\.md$/.test(name)) continue;
+    const lines = (readText(J(dir, name)) || '').split('\n');
+    const i = lines.findIndex((l) => l.indexOf(MARK) >= 0);
+    if (i < 0) continue;
+    const h = lines.find((l) => /^#\s+/.test(l)) || '';
+    out.push({ file: 'decisions/' + name, title: h.replace(/^#\s+/, '').trim(), line: i + 1 });
+  }
+  return { ok: true, root, decisions: out };
+}
+
+// --- auto-md ---------------------------------------------------------------------------------
+// The docs/AUTO.md body of D-03-07: objective, flags, the roteiro table, then two empty sections.
+function autoMd(root, objective, flagStr) {
+  const ev = {};
+  for (const s of detect(root).stages) ev[s.id] = s.evidence;
+  const r = roteiro(root, flagStr, objective);
+  const L = ['# AUTO — autonomous run', '',
+    '## Objective', '', String(objective || '').trim() || '<objective>', '',
+    '## Flags', '', String(flagStr || '').trim() || '(none)', '',
+    '## Roteiro', '', '| # | stage | command | status | evidence |', '|---|---|---|---|---|'];
+  r.roteiro.forEach((e, i) => L.push('| ' + (i + 1) + ' | ' + e.stage + ' | ' + e.command + ' | '
+    + e.status + ' | ' + (ev[e.stage] || '—') + ' |'));
+  if (!r.roteiro.length) {
+    L.push('| — | — | — | — | ' + (r.needs_objective ? 'no objective given' : 'nothing left to run') + ' |');
+  }
+  L.push('', '## Decisions taken alone', '', '(filled at the end of the run)', '',
+    '## Log', '', '(one dated line per stage transition)');
+  return { ok: true, root, markdown: L.join('\n') };
+}
+
+// --- cli -------------------------------------------------------------------------------------
+function parseArgv(argv) {
+  const flags = {}, pos = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    const kv = /^--([^=]+)=([\s\S]*)$/.exec(a);
+    if (kv) { flags[kv[1]] = kv[2]; continue; }
+    if (a === '--cwd' || a === '--flags' || a === '--objective') { flags[a.slice(2)] = argv[++i]; continue; }
+    if (/^--/.test(a)) { flags[a.slice(2)] = true; continue; }
+    pos.push(a);
+  }
+  return { flags, pos };
+}
+function rootOf(a) {
+  const r = path.resolve(String(a.flags.cwd || process.cwd()));
+  if (!isDir(r)) throw new Error('not a directory: ' + r);
+  return r;
+}
+const C = {
+  detect: (a) => detect(rootOf(a)),
+  roteiro: (a) => roteiro(rootOf(a), a.flags.flags, a.flags.objective),
+  'next-cmd': (a) => ({ ok: true, command: nextCmdOf(readText(path.resolve(a.pos[0] || ''))) }),
+  report: (a) => report(rootOf(a)),
+  'auto-md': (a) => autoMd(rootOf(a), a.flags.objective, a.flags.flags),
+};
+const FMT = {
+  detect: (r) => r.stages.map((s) => s.id.padEnd(12) + ' ' + s.status.padEnd(5) + ' ' + s.evidence).join('\n'),
+  roteiro: (r) => (r.needs_objective ? 'needs_objective'
+    : r.roteiro.map((e, i) => (i + 1) + '. ' + e.stage.padEnd(12) + ' ' + e.command
+      + (e.pause_after ? '  [pause]' : '')).join('\n')),
+  'next-cmd': (r) => r.command,
+  report: (r) => r.decisions.map((d) => d.file + ':' + d.line + '  ' + d.title).join('\n'),
+  'auto-md': (r) => r.markdown,
+};
+
+function main() {
+  const argv = process.argv.slice(2), cmd = argv[0];
+  try {
+    if (!C[cmd]) throw new Error('usage: ll-auto.js <' + Object.keys(C).join('|') + '> [args] [--cwd <dir>] [--json]');
+    const a = parseArgv(argv.slice(1));
+    const res = C[cmd](a);
+    process.stdout.write((a.flags.json || !FMT[cmd] ? JSON.stringify(res) : FMT[cmd](res)) + '\n');
+  } catch (e) {
+    process.stdout.write(JSON.stringify({ ok: false, reason: (e && e.message) || String(e) }) + '\n');
+  }
+  process.exit(0);
+}
+main();

package/skills/ll-brainstorm/SKILL.md

@@ -1,7 +1,8 @@
 ---
 name: ll-brainstorm
-description: "Opens a phase, a project or a loose idea by deciding in front of the owner instead of asking — scouts the repo, then shows one map (A: what Claude decides, each item with its repo analog at file:line; B: at most 4 calls only the owner can make, batched once; C: deferred) and ends with phases/NN/DECISIONS.md or docs/decide/OPENING.md plus the next command. Use when the owner says \"vamos discutir\", \"tenho uma ideia\", \"não sei ainda\", \"me ajuda a pensar\", \"brainstorm\", \"antes de começar a fase X\", \"abrir projeto novo\", \"li esse documento / áudio / transcrição, o que fazemos com isso\", \"a tentativa anterior não deu certo\" — or in English \"let's discuss\", \"I have an idea\", \"help me think\", \"before we start phase X\", \"new project\", \"the previous attempt failed\". Not for an already-specified request or a plan ready for adversarial pressure (both go to `ll-decide`), nor for a market question (`ll-research --market`)."
+description: Opens a phase, a project or a loose idea by deciding in front of the owner instead of asking, and writes the opening map to phases/NN/DECISIONS.md or docs/decide/OPENING.md with the next command.
 argument-hint: "[phase-number | project | chat] [--no-talk]"
+disable-model-invocation: true
 ---
 
 # Brainstorm
@@ -123,7 +124,7 @@ Write the file, print the score in three lines and the next command. Nothing is
 Closed. <k> locked by me (<r> revisable), <j> answered by you (<c> against the recommendation),
 <m> deferred. Questions asked <j> / assumptions <a> / band-1 open 0.   (printed even when <j> = 0)
 → phases/NN/DECISIONS.md
-▶ Next — `/clear` then `ll-implement NN`   (or "adjust X" if something is wrong)
+▶ Next — /clear, then ll-implement NN (or "adjust X" if something is wrong)
 ```
 
 File skeleton (8 sections, all present even when empty):
@@ -154,7 +155,7 @@ decision he did not make is a defect, not a rounding. Band-1 items and items tha
 phases also get `decisions/DEC-NNNN-<slug>.md`. The helper `${CLAUDE_CONFIG_DIR:-$HOME/.claude}/skills/ll-implement/scripts/ll-tools.js` is used only if it exists — this skill does not ship it; when it is absent,
 the DEC id is the next number after the highest in `decisions/`; with it, `dec-reserve <n>`.
 
-## Closing criterion
+## Completion criterion
 
 The conversation closes when four list comparisons hold — no model score:
 1. Zero Blocking items open (answered by the owner or explicitly deferred by him).
@@ -169,7 +170,7 @@ close A as it stands and handle the rest in execution, or take the premise that
 to `ll-decide project` (its premortem) as the next command." Budget: ≤4 turns on the phase route, ≤8 on project.
 
 Done when the file exists with its 8 sections and the Score line reads `0 band-1 items open`.
-▶ Next — `/clear` then `ll-implement NN` (phase route) · `ll-decide project` (project route) ·
+▶ Next — /clear, then ll-implement NN (phase route; project route: ll-decide project)
 nothing to run (chat route).
 
 ## References

package/skills/ll-brainstorm/references/decision-policy.md

@@ -61,6 +61,9 @@ Silence of 10 minutes ratifies the recommended list (A), never a blocking item (
 ## Silence, delegation, directives
 - Silence for 10 minutes in the hot window (harness AFK timeout) ratifies option A of a band-2/3 item or
   list A of a map — never option B, never a band-1 item. Record `ratified by silence`; in a run, `[decided by absence — revisable]`.
+- Under `--no-talk` the ten minutes are not waited for: the recommended option is taken at once and
+  recorded `[decided by absence — revisable]`. A band-1 item is never taken this way — it is written
+  as a decision in state `WAITING` and the work that depends on it stops there.
 - "Claude decide", "você decide", "pergunta pro time" are legitimate answers: record an assumption
   `ASM-n` (permanent; announced if changed later) or the delegation, and never ask that item again.
 - An order against the recommendation is a directive: one challenge with the cost named, then

package/skills/ll-close/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: ll-close
-description: Closes a delivery or a milestone — reconciles the backlog against executable conditions, writes docs/DELIVERY.md for the manager, stamps the epilogue with phase-stats, produces a retrospective, promotes the lessons that became permanent rules to project memory and CLAUDE.md, and asks for one block of ratification. Use when the request is "fecha", "fecha a fase", "pode arquivar", "encerra isso", "fecha o milestone", or at the end of a /goal; `--milestone` archives the phases, collapses the ROADMAP and updates the project's current state. It refuses to close without an approved VERIFICATION.md; for the verification itself use ll-verify.
-argument-hint: "[--milestone <name>]"
+description: Closes a phase or a delivery, reconciling the backlog against executable conditions, writing docs/DELIVERY.md, stamping the epilogue, recording the retrospective and asking for one block of ratification.
+argument-hint: "[--milestone <name>] [--no-talk]"
 disable-model-invocation: true
 allowed-tools: Bash(${CLAUDE_SKILL_DIR}/scripts/ll-tools.js *)
 ---
@@ -29,7 +29,7 @@ Reply to the owner in Portuguese; every file you write is in English.
 
 Read the verification for the target: the newest by mtime between `phases/NN/VERIFICATION.md` (phase) and `VERIFICATION.md` at the repo root (delivery); say which one opened the gate. Close only on `APPROVED`, or on `APPROVED_WITH_RESERVATIONS` whose reservations are accepted in a `decisions/DEC-*.md` naming them. Anything else — `REJECTED`, `product: FAIL`, `process: FAIL` with no DEC, no verification file at all — stops here:
 
-> Não fecho: `<motivo em uma linha>`. ▶ Next — `/clear`, then `ll-verify NN` (or record the reservations in a DEC and run `ll-close` again).
+> Não fecho: `<motivo em uma linha>`. ▶ Next — /clear, then ll-verify NN (or record the reservations in a DEC and run ll-close again)
 
 A verification whose ledger has `STALE` lines is verification of code that moved: it does not open the gate.
 
@@ -41,7 +41,7 @@ A verification whose ledger has `STALE` lines is verification of code that moved
 4. **Write `docs/RETROSPECTIVE-<date>.md`** from `references/retrospective.md` — about 60 lines, driven by the numbers from step 3, one lesson per line with the evidence that produced it.
 5. **Promote what is permanent.** A lesson that changes how the next phase runs goes to project memory; a lesson that is a standing rule of this repository goes as one line into the project's `CLAUDE.md`, in the owner's words when he gave them. Two lines at most per delivery: a CLAUDE.md that grows every close stops being read.
 6. **Peer notice.** If a peer session (infra, ops, another repo) shipped, waits on something, or was asked for something in `docs/REQUESTS.md`, that goes in the summary as one line with the request id and its state — not as a new message.
-7. **One block of ratification.** A single `AskUserQuestion`, at most 4 items, only after everything is written: the open pendings with their conditions, and the accepted risks the delivery carries. Options carry the cost of each path and the recommendation is marked. Silence keeps what is written; nothing here blocks the close.
+7. **One block of ratification.** A single `AskUserQuestion`, at most 4 items, only after everything is written: the open pendings with their conditions, and the accepted risks the delivery carries. Options carry the cost of each path and the recommendation is marked. Silence keeps what is written; nothing here blocks the close. With `--no-talk`, this block is not asked: the same items — open pendings with their conditions, accepted risks, recommendation — are written instead under the epilogue in PROGRESS.md and in DELIVERY.md §5, each line marked `[decided by absence — revisable]` with the date; the gate above is unchanged.
 8. **Report.** Verdict and seals, what changed in one line, numbers from `phase-stats`, open pendings by id, accepted risks, next command.
 
 ## Flow — `--milestone <name>`
@@ -53,7 +53,7 @@ The list always goes out; the audit ritual is optional and offered once, never i
 3. Collapse the closed phases in `ROADMAP.md` into one `<details>` block per phase, keeping the numbering intact — phase 7 stays phase 7 forever, and a later reference to it still resolves.
 4. Transport only what survives: an open pending with an executable condition goes to `BACKLOG.md`; a criterion never proven goes to the next milestone's ROADMAP as a criterion, not as a note. What survives neither test is dropped, and the report says which.
 5. Update `## Current state` in the project's `CLAUDE.md`: what exists now, what the next milestone is, where the history went. Replace the section; do not append to it.
-6. One block of ratification, as in the delivery flow, plus the open pendings the milestone inherits.
+6. One block of ratification, as in the delivery flow, plus the open pendings the milestone inherits. `--no-talk` follows the same rule: the block is not asked, and the same items are written under the epilogue instead.
 
 ## Completion criterion
 

package/skills/ll-close/references/delivery.md

@@ -42,7 +42,9 @@ reason, never omitted.>
 <What was decided on the owner's behalf while he was not there, one per line: the assumption, the
 DEC that records it, what breaks if it is wrong, and how expensive it is to reverse. This section
 feeds the ratification block; if it is empty, say "none — every decision in this delivery is in
-decisions/".>
+decisions/". Under `--no-talk`, this section also carries the open pendings, accepted risks and
+recommendation that would otherwise be asked in the ratification block, each line ending
+`[decided by absence — revisable]` and the date.>
 
 ## 6. Out of this round, and why
 <What was asked for or found and deliberately not done. One line each: what, why (cost, risk,