@ionivetech/mugiwara 0.6.1 → 0.6.3

package/scripts/release-notes.ts

@@ -1,94 +1,171 @@
 #!/usr/bin/env bun
 // scripts/release-notes.ts — generates a detailed GitHub Release description
 // from git history between the previous tag and HEAD. Pulls the full commit
-// message (subject + body), groups by conventional-commit type, flags breaking
-// changes, and lists the affected scopes. No gh dependency.
+// message (subject + body), groups by conventional-commit scope (feature area)
+// in first-appearance order, falls back to type for unscoped commits, flags
+// breaking changes, and lists the affected scopes. No gh dependency.
 //
 //   bun scripts/release-notes.ts                 notes since the last tag → stdout
 //   bun scripts/release-notes.ts --since v0.3.0   notes from that tag → stdout
 import { execFileSync } from 'node:child_process';
 
-const args = process.argv;
-const sinceIdx = args.indexOf('--since');
-let since = sinceIdx !== -1 ? args[sinceIdx + 1] : null;
-
-if (!since) {
-  // The release workflow tags HEAD BEFORE generating notes, so the newest tag
-  // is the release tag itself. The "since" boundary must be the tag BEFORE it,
-  // otherwise range = "<release>..HEAD" is empty and the notes come out blank.
-  // With only one tag (first release), there is no previous tag — show all.
-  const tags = execFileSync('git', ['tag', '--sort=-version:refname'], { encoding: 'utf8' })
-    .split(/\r?\n/).filter(Boolean);
-  since = tags.length >= 2 ? tags[1] : null;
-}
-
-const range = since ? `${since}..HEAD` : '';
-const raw = execFileSync('git', ['log', '--pretty=%H%n%s%n%n%b%n__END__', ...(range ? [range] : [])], { encoding: 'utf8' });
-const commits = raw
-  .split('__END__\n')
-  .map(c => c.trim())
-  .filter(Boolean)
-  .map(c => {
-    const [sha, subject, ...rest] = c.split('\n');
-    return { sha: sha.slice(0, 7), subject: subject ?? '', body: rest.join('\n').trim() };
-  });
-
-const groups: Record<string, { label: string; items: string[] }> = {
-  feat: { label: 'New', items: [] },
-  fix: { label: 'Fixed', items: [] },
-  refactor: { label: 'Refactored', items: [] },
-  perf: { label: 'Performance', items: [] },
-  docs: { label: 'Docs', items: [] },
-  chore: { label: 'Housekeeping', items: [] },
-  test: { label: 'Housekeeping', items: [] },
-  ci: { label: 'Housekeeping', items: [] },
+// human label for a conventional-commit type: section fallback + per-bullet tag
+const TYPE_LABEL: Record<string, string> = {
+  feat: 'New',
+  fix: 'Fixed',
+  refactor: 'Refactored',
+  perf: 'Performance',
+  docs: 'Docs',
+  chore: 'Housekeeping',
+  test: 'Housekeeping',
+  ci: 'Housekeeping',
 };
 
-const order = ['feat', 'fix', 'refactor', 'perf', 'docs', 'chore'];
+const TYPE_ORDER = ['feat', 'fix', 'refactor', 'perf', 'docs', 'chore'];
 
 // strip signature trailers (Co-authored-by, Signed-off-by, review notes)
 const TRAILER = /^(Co-authored-by|Signed-off-by|Reviewed-by|Helped-by|Reported-by|Tested-by|Acked-by):/i;
 
-for (const commit of commits) {
-  const m = /^(\w+)(?:\((.*?)\))?!?: (.*)/.exec(commit.subject);
-  const type = m ? m[1] : 'chore';
-  const scope = m?.[2] || '';
-  const text = m ? m[3] : commit.subject;
-  const breaking = Boolean(m?.[0]?.includes('!')) || /^BREAKING CHANGE:/m.test(commit.body);
-
-  const title = text.charAt(0).toUpperCase() + text.slice(1);
-  const scopeTag = scope ? ` \`${scope}\`` : '';
-  const breakingTag = breaking ? ' ⚠️ **BREAKING**' : '';
-
-  const bodyLines = commit.body
-    .split(/\r?\n/)
-    .map(l => l.trim())
-    .filter(l => l && !TRAILER.test(l) && l !== '---')
-    // the release-version marker commit repeats the subject as body — drop it
-    .filter(l => l !== text);
-
-  let entry = `- ${title}${scopeTag}${breakingTag} \`${commit.sha}\``;
-  if (bodyLines.length) {
-    entry += '\n' + bodyLines.map(l => `  - ${l}`).join('\n');
-  }
-  const g = groups[type] ?? groups.chore;
-  g.items.push(entry);
+// capitalize the first letter of each word; split on non-alphanumerics
+// (opencode → Opencode, release-notes → Release Notes)
+const titleCase = (s: string) =>
+  s
+    .split(/[^a-zA-Z0-9]+/)
+    .filter(Boolean)
+    .map(w => w.charAt(0).toUpperCase() + w.slice(1))
+    .join(' ');
+
+export interface ReleaseCommit {
+  sha: string;
+  subject: string;
+  body: string;
 }
 
-const lines: string[] = [];
-for (const t of order) {
-  const g = groups[t];
-  if (!g.items.length) continue;
-  lines.push(`## ${g.label}`);
-  lines.push('');
-  for (const item of g.items) lines.push(item);
-  lines.push('');
+/**
+ * Group parsed commits into per-scope sections (first-appearance order) with a
+ * type-fallback for unscoped commits. Returns the rendered markdown body and
+ * the change count. Pure — no git access, deterministic. Exported so tests
+ * exercise the grouping without invoking git.
+ */
+export function buildNotes(commits: ReleaseCommit[]): { count: number; markdown: string } {
+  // scoped (feature-area) sections, keyed by lowercased scope, first-appearance order
+  const scoped = new Map<string, { label: string; items: string[] }>();
+  const scopedOrder: string[] = [];
+  // unscoped fallback sections by type, rendered in canonical type order
+  const byType = new Map<string, { label: string; items: string[] }>();
+  for (const t of TYPE_ORDER) byType.set(t, { label: TYPE_LABEL[t], items: [] });
+
+  for (const commit of commits) {
+    const m = /^(\w+)(?:\((.*?)\))?(!)?: (.*)/.exec(commit.subject);
+    const type = m ? m[1] : 'chore';
+    const scope = m?.[2] || '';
+    const text = m ? m[4] : commit.subject;
+    // the conventional-commits `!` breaking marker sits between scope and
+    // colon; capture it positionally so `fix: handle a! in parser` is NOT
+    // flagged breaking (a bare `!` anywhere in the subject would be)
+    const breaking = m?.[3] === '!' || /^BREAKING CHANGE:/m.test(commit.body);
+
+    const title = text.charAt(0).toUpperCase() + text.slice(1);
+    const breakingTag = breaking ? ' ⚠️ **BREAKING**' : '';
+
+    const bodyLines = commit.body
+      .split(/\r?\n/)
+      .map(l => l.trim())
+      .filter(l => l && !TRAILER.test(l) && l !== '---')
+      // the release-version marker commit repeats the subject as body — drop it
+      .filter(l => l !== text);
+
+    const typeLabel = TYPE_LABEL[type] ?? 'Housekeeping';
+    const base = `${title}${breakingTag} \`${commit.sha}\``;
+    const bodyBlock = bodyLines.length ? '\n' + bodyLines.map(l => `  - ${l}`).join('\n') : '';
+
+    if (scope) {
+      const key = scope.toLowerCase();
+      let g = scoped.get(key);
+      if (!g) {
+        g = { label: titleCase(scope), items: [] };
+        scoped.set(key, g);
+        scopedOrder.push(key);
+      }
+      // scoped (feature-area) sections: the type label adds information because
+      // the heading names the area, not the type
+      g.items.push(`- **${typeLabel}** ${base}${bodyBlock}`);
+    } else {
+      // type-fallback sections: the heading already names the type, so a
+      // per-bullet label would be redundant (R5a)
+      (byType.get(type) ?? byType.get('chore')!).items.push(`- ${base}${bodyBlock}`);
+    }
+  }
+
+  // Render into a heading-keyed map (case-insensitive) so a type-fallback
+  // heading that collides with an earlier scoped heading merges into it
+  // instead of emitting a duplicate section (R5b).
+  const sections = new Map<string, { heading: string; items: string[] }>();
+  const order: string[] = [];
+  const addSection = (heading: string, items: string[]) => {
+    const key = heading.toLowerCase();
+    let s = sections.get(key);
+    if (!s) {
+      s = { heading, items: [] };
+      sections.set(key, s);
+      order.push(key);
+    }
+    s.items.push(...items);
+  };
+
+  // scoped (feature-area) sections first, in order of first appearance
+  for (const key of scopedOrder) addSection(scoped.get(key)!.label, scoped.get(key)!.items);
+  // then unscoped type-fallback sections, canonical type order
+  for (const t of TYPE_ORDER) {
+    const g = byType.get(t)!;
+    if (g.items.length) addSection(g.label, g.items);
+  }
+
+  const lines: string[] = [];
+  for (const key of order) {
+    const s = sections.get(key)!;
+    lines.push(`## ${s.heading}`);
+    lines.push('');
+    for (const item of s.items) lines.push(item);
+    lines.push('');
+  }
+
+  const bumpIdx = commits.findIndex(c => /chore: release|chore: bump/.test(c.subject));
+  const body = commits.slice(0, bumpIdx === -1 ? commits.length : bumpIdx);
+  const count = body.length || commits.length;
+
+  return { count, markdown: lines.join('\n').trimEnd() };
 }
 
-const bumpIdx = commits.findIndex(c => /chore: release|chore: bump/.test(c.subject));
-const body = commits.slice(0, bumpIdx === -1 ? commits.length : bumpIdx);
-const count = body.length || commits.length;
+// Guard the CLI path so importing buildNotes in tests does not run git.
+if (import.meta.main) {
+  const args = process.argv;
+  const sinceIdx = args.indexOf('--since');
+  let since = sinceIdx !== -1 ? args[sinceIdx + 1] : null;
+
+  if (!since) {
+    // The release workflow tags HEAD BEFORE generating notes, so the newest tag
+    // is the release tag itself. The "since" boundary must be the tag BEFORE it,
+    // otherwise range = "<release>..HEAD" is empty and the notes come out blank.
+    // With only one tag (first release), there is no previous tag — show all.
+    const tags = execFileSync('git', ['tag', '--sort=-version:refname'], { encoding: 'utf8' })
+      .split(/\r?\n/).filter(Boolean);
+    since = tags.length >= 2 ? tags[1] : null;
+  }
 
-console.log(`**${count} change${count === 1 ? '' : 's'} since ${since ?? 'the start'}.**`);
-console.log('');
-console.log(lines.join('\n').trimEnd());
+  const range = since ? `${since}..HEAD` : '';
+  const raw = execFileSync('git', ['log', '--pretty=%H%n%s%n%n%b%n__END__', ...(range ? [range] : [])], { encoding: 'utf8' });
+  const commits: ReleaseCommit[] = raw
+    .split('__END__\n')
+    .map(c => c.trim())
+    .filter(Boolean)
+    .map(c => {
+      const [sha, subject, ...rest] = c.split('\n');
+      return { sha: sha.slice(0, 7), subject: subject ?? '', body: rest.join('\n').trim() };
+    });
+
+  const { count, markdown } = buildNotes(commits);
+  console.log(`**${count} change${count === 1 ? '' : 's'} since ${since ?? 'the start.'}**`);
+  console.log('');
+  console.log(markdown);
+}

package/scripts/savepoint.sh

@@ -1,30 +1,54 @@
 #!/usr/bin/env bash
-# scripts/savepoint.sh — write .mugiwara/state.json at every wave boundary.
-# Computed from git + file counts; zero model judgement.
+# scripts/savepoint.sh — write .mugiwara/state/<mission>/<member>.json at every
+# wave boundary. Computed from git + file counts; zero model judgement.
+# Identity is (mission, member), never branch. Solo = member empty → the file
+# is named state.json. Usage:
+#   savepoint.sh <mission> [member] [wave] [mode]
 set -u
 
 die() { echo "savepoint: $*" >&2; exit 1; }
 
 MUGIWARA_DIR="${MUGIWARA_DIR:-.mugiwara}"
 
-# --- parse mission args ---
-# --branch flag must parse FIRST — it shifts positionals
-BRANCH_MODE=0
-if [ "${1:-}" = "--branch" ]; then
-  BRANCH_MODE=1
-  shift
-  MISSION="${1:-${STATE_MISSION:-}}"
-  ACTOR="${2:-${STATE_ACTOR:-${GIT_AUTHOR_NAME:-${USER:-}}}}"
-  BRANCH="${3:-$(git branch --show-current 2>/dev/null || echo 'unknown')}"
-  WAVE="${4:-${STATE_WAVE:-1}}"
-  MODE="${5:-${STATE_MODE:-guided}}"
-else
-  MISSION="${1:-${STATE_MISSION:-}}"
-  ACTOR="${2:-${STATE_ACTOR:-${GIT_AUTHOR_NAME:-${USER:-}}}}"
-  BRANCH="${3:-$(git branch --show-current 2>/dev/null || echo 'unknown')}"
-  WAVE="${4:-${STATE_WAVE:-1}}"
-  MODE="${5:-${STATE_MODE:-guided}}"
-fi
+# shared path patterns — single source of truth (D3)
+# shellcheck source=scripts/lib/patterns.sh
+source "$(dirname "$0")/lib/patterns.sh"
+# shared lane budgets — single source of truth (D5), validated by lane-base.ts
+# shellcheck source=scripts/lib/lane-base.sh
+source "$(dirname "$0")/lib/lane-base.sh"
+
+# lane ordering: direct < lean < standard < full < spike (spike resizes, not a rise)
+lane_rank() {
+  case "$1" in
+    direct) echo 0 ;;
+    lean) echo 1 ;;
+    standard) echo 2 ;;
+    full) echo 3 ;;
+    spike) echo 4 ;;
+    *) echo 0 ;;
+  esac
+}
+
+# --- git identity for actor attribution ---
+# Resolve once from repo git config; used when no actor is passed explicitly.
+# GIT_AUTHOR_NAME is an env var usually unset — falling through to $USER
+# attributes the savepoint to the OS user instead of the git identity.
+GIT_NAME="$(git config user.name 2>/dev/null || true)"
+GIT_EMAIL="$(git config user.email 2>/dev/null || true)"
+if [ -n "$GIT_NAME" ] && [ -n "$GIT_EMAIL" ]; then GIT_ID="$GIT_NAME <$GIT_EMAIL>"; else GIT_ID="$GIT_NAME"; fi
+
+# --- parse mission args: <mission> [member] [wave] [mode] ---
+MISSION="${1:-${STATE_MISSION:-}}"
+MEMBER="${2:-${STATE_MEMBER:-}}"
+WAVE="${3:-${STATE_WAVE:-1}}"
+MODE="${4:-${STATE_MODE:-guided}}"
+ACTOR="${STATE_ACTOR:-${GIT_AUTHOR_NAME:-${GIT_ID:-${USER:-}}}}"
+BRANCH="$(git branch --show-current 2>/dev/null || echo 'unknown')"
+
+# treat the legacy empty-actor placeholder '""' as "no member" (solo). The old
+# interface used '""' for the actor slot; the new (mission, member) interface
+# uses an empty arg. Accept both so callers need not know which one.
+if [ "$MEMBER" = '""' ]; then MEMBER=""; fi
 
 # mission allowlist — MISSION feeds paths + sed + node argv; traversal or
 # sed metacharacters must not reach filesystem operations
@@ -37,15 +61,32 @@ if [[ "$MISSION" =~ ^\.+$ ]]; then
   die "invalid mission name \"$MISSION\" (allowlist: [a-zA-Z0-9._-], not a dot-path)"
 fi
 
-# per-branch state file when --branch used
-BRANCH_SLUG=$(echo "$BRANCH" | tr '/' '-')
-if [ "$BRANCH_MODE" -eq 1 ]; then
-  STATE_FILE="$MUGIWARA_DIR/state-${BRANCH_SLUG}.json"
+# member allowlist — MEMBER feeds a per-member file name; same rules as MISSION.
+case "$MEMBER" in
+  *[!a-zA-Z0-9._-]*) die "invalid member name \"$MEMBER\" (allowlist: [a-zA-Z0-9._-])" ;;
+esac
+if [[ "$MEMBER" =~ ^\.+$ ]]; then
+  die "invalid member name \"$MEMBER\" (allowlist: [a-zA-Z0-9._-], not a dot-path)"
+fi
+
+# BRANCH_SLUG sanitized to [A-Za-z0-9._-] — it feeds the continue branch field;
+# a newline/control char in BRANCH would corrupt the JSON (F5). Dropping illegal
+# chars is safe: slugs are keys, not content. Dot-only slugs emptied
+# (BSD/macOS-safe: no \+ BRE).
+BRANCH_SLUG=$(echo "$BRANCH" | tr '/' '-' | tr -cd 'A-Za-z0-9._-' | sed 's/^\.\{1,\}$//' )
+
+# state + continue live per (mission, member). Solo (member empty) → state.json.
+STATE_DIR="$MUGIWARA_DIR/state/$MISSION"
+CONTINUE_DIR="$MUGIWARA_DIR/continue/$MISSION"
+if [ -n "$MEMBER" ]; then
+  STATE_FILE="$STATE_DIR/$MEMBER.json"
+  CONTINUE_FILE="$CONTINUE_DIR/$MEMBER.json"
 else
-  STATE_FILE="$MUGIWARA_DIR/state.json"
+  STATE_FILE="$STATE_DIR/state.json"
+  CONTINUE_FILE="$CONTINUE_DIR/state.json"
 fi
 
-[ -z "$MISSION" ] && die "usage: savepoint.sh <mission> [actor] [branch] [wave] [mode]"
+[ -z "$MISSION" ] && die "usage: savepoint.sh <mission> [member] [wave] [mode]"
 [ -d .git ] || die "not a git repository"
 
 # --- computed fields ---
@@ -55,17 +96,23 @@ HEAD_SHA=$(git rev-parse HEAD 2>/dev/null || echo "unknown")
 CHANGED_FILES=$(git diff --name-only "$BASE_SHA"..HEAD 2>/dev/null || git diff --name-only --cached 2>/dev/null || true)
 FILES_TOUCHED=$( [ -n "$CHANGED_FILES" ] && echo "$CHANGED_FILES" | wc -l | tr -d ' ' || echo 0 )
 
+LOC_INS=0
+LOC_DEL=0
 LOC_DELTA=0
+LOC_CHURN=0
 if [ "$BASE_SHA" != "unknown" ]; then
   STAT=$(git diff --shortstat "$BASE_SHA"..HEAD 2>/dev/null || echo "")
   INS=$(echo "$STAT" | grep -oE '[0-9]+ insertion' | grep -oE '[0-9]+' || echo 0)
   DEL=$(echo "$STAT" | grep -oE '[0-9]+ deletion'  | grep -oE '[0-9]+' || echo 0)
-  LOC_DELTA=$(( ${INS:-0} - ${DEL:-0} ))
+  LOC_INS=$(( ${INS:-0} + 0 ))
+  LOC_DEL=$(( ${DEL:-0} + 0 ))
+  LOC_DELTA=$(( LOC_INS - LOC_DEL ))
+  # churn is insertion+deletion — refactors and deletions are work too (D4)
+  LOC_CHURN=$(( LOC_INS + LOC_DEL ))
 fi
 [ -z "$LOC_DELTA" ] && LOC_DELTA=0
 
-SENSITIVE_PATTERNS="auth/|payment/|billing/|crypto/|secrets/|\.env$|config/.*key|migration/|\.sql$|schema\.|\.prisma$|\.terraform|\.tf$"
-SENSITIVE_PATHS=$(echo "$CHANGED_FILES" | grep -E "$SENSITIVE_PATTERNS" 2>/dev/null | tr '\n' ',' | sed 's/,$//' || true)
+SENSITIVE_PATHS=$(echo "$CHANGED_FILES" | grep -E "$SENSITIVE_PATS" 2>/dev/null | tr '\n' ',' | sed 's/,$//' || true)
 
 LANE="direct"
 LANE_REASON=""
@@ -101,7 +148,6 @@ fi
 # path-weighted sizing (mirrors lane.sh): docs-only changes outside the product
 # surface never escalate to full from file count alone; sensitive-path
 # escalation above still wins.
-PRODUCT_PAT="^content/|^src/|^scripts/|^test/|^hooks/|^\.opencode/|^\.claude/|^evals/"
 if [ "$LANE" = "full" ] && [ -z "$SENSITIVE_PATHS" ] && [ -n "$CHANGED_FILES" ]; then
   CODE_COUNT=$(echo "$CHANGED_FILES" | grep -E "$PRODUCT_PAT" 2>/dev/null | grep -c . || true)
   if [ -z "$CODE_COUNT" ] || [ "$CODE_COUNT" -eq 0 ] 2>/dev/null; then
@@ -111,6 +157,42 @@ if [ "$LANE" = "full" ] && [ -z "$SENSITIVE_PATHS" ] && [ -n "$CHANGED_FILES" ];
   fi
 fi
 
+# --- lane-rise compare (F9) + monotonic clamp (D2): read previous state ---
+# Clamp runs here — before LANE_BASE/BUDGET — so tokens and budget follow the
+# held lane, never the raw shrunken one.
+LANE_PREV=""
+LANE_PEAK=""
+LANE_ROSE=false
+PREV_MISSION=""
+if [ -f "$STATE_FILE" ]; then
+  PREV_JSON=$(node -e "try{const fs=require('fs');const s=JSON.parse(fs.readFileSync(process.argv[1],'utf8'));process.stdout.write(JSON.stringify({mission:s.mission||'',lane:s.lane||'',peak:s.lane_peak||''}))}catch(e){process.stdout.write('{}')}" "$STATE_FILE" 2>/dev/null || true)
+  PREV_MISSION=$(echo "$PREV_JSON" | node -e "let d='';process.stdin.on('data',c=>d+=c).on('end',()=>{try{process.stdout.write(JSON.parse(d).mission||'')}catch(e){process.stdout.write('')}})" 2>/dev/null || true)
+  LANE_PREV=$(echo "$PREV_JSON" | node -e "let d='';process.stdin.on('data',c=>d+=c).on('end',()=>{try{process.stdout.write(JSON.parse(d).lane||'')}catch(e){process.stdout.write('')}})" 2>/dev/null || true)
+  LANE_PEAK=$(echo "$PREV_JSON" | node -e "let d='';process.stdin.on('data',c=>d+=c).on('end',()=>{try{process.stdout.write(JSON.parse(d).peak||'')}catch(e){process.stdout.write('')}})" 2>/dev/null || true)
+fi
+# fresh mission resets the clamp: a different mission in state.json is a new
+# run, not a lane drop — no carry-over of peak or prev (case 10).
+if [ -n "$PREV_MISSION" ] && [ "$PREV_MISSION" != "$MISSION" ]; then
+  LANE_PREV=""
+  LANE_PEAK=""
+fi
+# monotonic clamp: never drop below the previous peak; spike is a resize, not a rise.
+if [ -n "$LANE_PEAK" ] && [ "$LANE_PEAK" != "spike" ] && [ "$(lane_rank "$LANE")" -lt "$(lane_rank "$LANE_PEAK")" ]; then
+  LANE="$LANE_PEAK"
+  LANE_REASON="$LANE_REASON (held at peak $LANE — clamp D2)"
+fi
+if [ -z "$LANE_PEAK" ] || [ "$LANE_PEAK" = "spike" ]; then
+  LANE_PEAK="$LANE"
+elif [ "$(lane_rank "$LANE")" -gt "$(lane_rank "$LANE_PEAK")" ]; then
+  LANE_PEAK="$LANE"
+fi
+if [ -n "$LANE_PREV" ] && [ "$LANE_PREV" != "$LANE" ]; then
+  case "$LANE_PREV:$LANE" in
+    direct:lean|direct:standard|direct:full|lean:standard|lean:full|standard:full) LANE_ROSE=true ;;
+    *) LANE_ROSE=false ;;
+  esac
+fi
+
 # task counts from plan doc — plan is written date-prefixed (plans/YYYY-MM-DD-<mission>.md)
 # or bare (plans/<mission>.md); glob both, first match wins.
 PLAN_FILE=$(ls "$MUGIWARA_DIR"/plans/${MISSION}.md "$MUGIWARA_DIR"/plans/*-${MISSION}.md 2>/dev/null | head -1 || true)
@@ -160,17 +242,18 @@ fi
 
 # tokens proxy (F7): deterministic estimate when the harness does not report
 # real usage. Monotonic beats precise — LANE_BASE stands in for the skills
-# loaded this lane; loc_delta and written-artifact words scale with growth.
+# loaded this lane (measured from content, validated by scripts/lane-base.ts);
+# loc_churn and written-artifact words scale with growth.
 # MUGIWARA_TOKENS overrides as the reported value.
 LANE_BASE=0
 case "$LANE" in
-  lean) LANE_BASE=1500 ;;
-  standard) LANE_BASE=4000 ;;
-  full) LANE_BASE=9000 ;;
-  spike) LANE_BASE=1000 ;;
+  lean) LANE_BASE=$LANE_BASE_lean ;;
+  standard) LANE_BASE=$LANE_BASE_standard ;;
+  full) LANE_BASE=$LANE_BASE_full ;;
+  spike) LANE_BASE=$LANE_BASE_spike ;;
 esac
 DOC_WORDS=$(cat "$MUGIWARA_DIR"/results/${MISSION}/*.md "$MUGIWARA_DIR"/plans/${MISSION}.md "$MUGIWARA_DIR"/plans/*-${MISSION}.md "$MUGIWARA_DIR"/spec/${MISSION}.md "$MUGIWARA_DIR"/spec/*-${MISSION}.md "$MUGIWARA_DIR"/logs/${MISSION}.md "$MUGIWARA_DIR"/logs/*-${MISSION}.md 2>/dev/null | wc -w | tr -d ' ')
-LOC_TOKENS=$(( LOC_DELTA > 0 ? LOC_DELTA * 12 : 0 ))
+LOC_TOKENS=$(( LOC_CHURN * 12 ))
 TOKENS_SOURCE="computed"
 TOKENS_EST=$(( LANE_BASE + DOC_WORDS * 135 / 100 + LOC_TOKENS ))
 if [ -n "${MUGIWARA_TOKENS:-}" ]; then
@@ -181,10 +264,10 @@ fi
 # budget per lane
 BUDGET=0
 case "$LANE" in
-  lean) BUDGET=4000 ;;
-  standard) BUDGET=10000 ;;
-  full) BUDGET=20000 ;;
-  spike) BUDGET=3000 ;;
+  lean) BUDGET=$BUDGET_lean ;;
+  standard) BUDGET=$BUDGET_standard ;;
+  full) BUDGET=$BUDGET_full ;;
+  spike) BUDGET=$BUDGET_spike ;;
   *) BUDGET=0 ;;
 esac
 
@@ -198,30 +281,18 @@ elif [ "$BUDGET" -gt 0 ] && [ "$TOKENS_EST" -ge "$WARN_AT" ] 2>/dev/null; then
   STATUS="warn"
 fi
 
-mkdir -p "$MUGIWARA_DIR"
-
-# --- lane-rise compare (F9): read previous state, flag escalation ---
-LANE_PREV=""
-LANE_ROSE=false
-if [ -f "$STATE_FILE" ]; then
-  LANE_PREV=$(node -e "try{const s=require(process.argv[1]);process.stdout.write(s.lane||'')}catch(e){process.stdout.write('')}" "$STATE_FILE" 2>/dev/null || true)
-  if [ -n "$LANE_PREV" ] && [ "$LANE_PREV" != "$LANE" ]; then
-    # lane order: direct < lean < standard < full < spike (spike resizes, not a rise)
-    case "$LANE_PREV:$LANE" in
-      direct:lean|direct:standard|direct:full|lean:standard|lean:full|standard:full) LANE_ROSE=true ;;
-      *) LANE_ROSE=false ;;
-    esac
-  fi
-fi
+mkdir -p "$MUGIWARA_DIR/state/$MISSION" "$MUGIWARA_DIR/continue/$MISSION"
 
 node -e "
 const data = {
   mission: process.argv[1],
+  member: process.argv[31] || null,
   actor: process.argv[2],
   branch: process.argv[3],
   lane: process.argv[4],
   lane_reason: process.argv[5],
   lane_prev: process.argv[24] || null,
+  lane_peak: process.argv[27] || null,
   lane_rose: process.argv[25] === 'true',
   wave: parseInt(process.argv[6], 10),
   mode: process.argv[7],
@@ -229,6 +300,9 @@ const data = {
   head_sha: process.argv[9],
   files_touched: parseInt(process.argv[10], 10),
   loc_delta: parseInt(process.argv[11], 10),
+  loc_ins: parseInt(process.argv[28], 10) || 0,
+  loc_del: parseInt(process.argv[29], 10) || 0,
+  loc_churn: parseInt(process.argv[30], 10) || 0,
   sensitive_paths: process.argv[12] ? process.argv[12].split(',').filter(Boolean) : [],
   tasks: { done: parseInt(process.argv[13], 10), total: parseInt(process.argv[14], 10) },
   blockers_open: parseInt(process.argv[15], 10),
@@ -249,9 +323,57 @@ require('fs').writeFileSync(process.argv[23], JSON.stringify(data, null, 2) + '\
   "$BLOCKERS_OPEN" "$HEAL_CYCLE" "$TOKENS_EST" "$BUDGET" \
   "$STATUS" "$SKILL_VERSION" "$EVIDENCE" \
   "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
-  "$STATE_FILE" "$LANE_PREV" "$LANE_ROSE" "$TOKENS_SOURCE"
+  "$STATE_FILE" "$LANE_PREV" "$LANE_ROSE" "$TOKENS_SOURCE" "$LANE_PEAK" \
+  "$LOC_INS" "$LOC_DEL" "$LOC_CHURN" "$MEMBER"
 
 if [ "$LANE_ROSE" = true ]; then
   echo "⚠ LANE ROSE: $LANE_PREV → $LANE ($LANE_REASON) — escalate per check-in protocol"
 fi
+
+# --- continue/<mission>/<member>.json (D10): machine-written resume point ---
+# Written alongside state.json so an interrupted session (step-limit truncation,
+# crash, new session) can resume without human recall. Same trust as state.json:
+# computed fields, never model judgement. The resume skill treats it as data to
+# verify against the plan/todos, never verbatim instructions.
+# Scoped by (mission, member) like state.json — solo writes state.json, team
+# writes <member>.json, so parallel members never clobber each other. The
+# crew-written next_session_prompt line is preserved across savepoints.
+if [ -n "$MISSION" ]; then
+  NEXT_SESSION_PROMPT=""
+  if [ -f "$CONTINUE_FILE" ]; then
+    NEXT_SESSION_PROMPT=$(node -e "try{const s=JSON.parse(require('fs').readFileSync(process.argv[1],'utf8'));process.stdout.write(s.next_session_prompt||'')}catch(e){process.stdout.write('')}" "$CONTINUE_FILE" 2>/dev/null || true)
+  fi
+  # N2: every field echoed into continue is validated first. MISSION + MEMBER
+  # are allowlisted upstream; WAVE numeric, MODE enum, BRANCH slug-sanitized.
+  CONT_WAVE=$(echo "$WAVE" | tr -cd '0-9')
+  case "$MODE" in
+    guided|semi|auto) CONT_MODE="$MODE" ;;
+    *) CONT_MODE="guided" ;;
+  esac
+  CONT_BRANCH="${BRANCH_SLUG:-unknown}"
+  node -e "
+  const fs = require('fs');
+  const data = {
+    mission: process.argv[1],
+    member: process.argv[2] || null,
+    actor: process.argv[13] || '',
+    branch: process.argv[3],
+    wave: parseInt(process.argv[4], 10) || 0,
+    mode: process.argv[5],
+    tasks_done: parseInt(process.argv[6], 10) || 0,
+    tasks_total: parseInt(process.argv[7], 10) || 0,
+    lane: process.argv[8],
+    lane_prev: process.argv[9] || null,
+    updated_at: process.argv[10],
+    next_action: 'verify this wave against the plan, then continue per plan (next wave or closure)'
+  };
+  try { data.next_session_prompt = JSON.parse(fs.readFileSync(process.argv[12],'utf8')).next_session_prompt || ''; } catch (e) { data.next_session_prompt = ''; }
+  fs.writeFileSync(process.argv[11], JSON.stringify(data, null, 2) + '\n');
+  " \
+    "$MISSION" "$MEMBER" "$CONT_BRANCH" "$CONT_WAVE" "$CONT_MODE" \
+    "$TASKS_DONE" "$TASKS_TOTAL" "$LANE" "$LANE_PREV" \
+    "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+    "$CONTINUE_FILE" "$CONTINUE_FILE" "$ACTOR"
+fi
+
 echo "✓ savepoint written: $STATE_FILE (lane=$LANE, wave=$WAVE, files=$FILES_TOUCHED)"