@oevery/rsp 3.1.0-beta.3 → 3.1.0-beta.4

package/dist/cli.mjs

@@ -4,7 +4,7 @@ import {
   installPackagedSkills,
   printPackagedSkillInventory,
   printSkillInstallResult
-} from "./chunk-NX55NIC3.mjs";
+} from "./chunk-D7XDXBFO.mjs";
 import {
   ArchiveHistoryError,
   GROUP_BRIEF_FILENAME,
@@ -21,6 +21,8 @@ import {
   inspectFocusTree,
   inspectProjectStatus,
   inspectWorkTree,
+  normalizeExecutableWorkRef,
+  normalizeWorkRefSegment,
   projectDependencyForest,
   queryArchiveHistory,
   readArchiveHistoryDetail,
@@ -29,12 +31,14 @@ import {
   resolveFocusMarkerPath,
   resolveWorkRef,
   selectArchiveHistoryRecord
-} from "./chunk-7KKAUBKN.mjs";
+} from "./chunk-FI3SYHVH.mjs";
 import {
   ARCHIVES_DIR,
   CHANGES_DIR,
+  CHANGE_DOCUMENT_SCHEMA,
   CONFIG_PATH,
   DEFAULT_DECISION_RECORDS_PATH,
+  DocumentSectionCardinalityError,
   FOCUS_DIR,
   LOCK_PATH,
   OBSOLETE_RSP_RULES_PATH,
@@ -42,6 +46,7 @@ import {
   RSP_DIR,
   RSP_RULES_PATH,
   VALID_KINDS,
+  appendDocumentSectionItem,
   buildDurableReviewGuidance,
   cleanupEmptyParentDirs,
   clearConfigCache,
@@ -56,6 +61,8 @@ import {
   generateChangeContent,
   generateDesignContent,
   generateSpecContent,
+  getDocumentSectionDefinitionByHeading,
+  getDocumentSections,
   getDurableReviewCandidateTargets,
   getVersion,
   guardRspInitialized,
@@ -70,6 +77,7 @@ import {
   loadRspConfig,
   normalizeLogicalPath,
   parseFrontmatter,
+  parseRspDocument,
   parseScenarios,
   pc,
   recordRuntimeDiagnostic,
@@ -83,7 +91,7 @@ import {
   validateDecisionRecordsFilesystemPath,
   walkMarkdownFiles,
   writeManagedFile
-} from "./chunk-OTJFL6XH.mjs";
+} from "./chunk-FJVH7ZYU.mjs";
 
 // src/cli.ts
 import { resolve } from "path";
@@ -418,7 +426,7 @@ async function addSpec(name, projectName = "project") {
 }
 
 // src/commands/archive.ts
-import { existsSync } from "fs";
+import { existsSync, readdirSync } from "fs";
 import { mkdir as mkdir3, readFile as readFile3, rename, unlink as unlink4 } from "fs/promises";
 import { basename as basename2, join as join3 } from "path";
 async function archiveChange(name) {
@@ -436,7 +444,7 @@ async function archiveChange(name) {
       const content = await readFile3(srcPath, "utf-8");
       const dependencyInspection = await inspectChangeDependencies();
       const checklist = collectArchiveChecklist(content, {
-        activeBlockers: dependencyInspection.activeBlockers.get(name)
+        activeBlockers: dependencyInspection.activeBlockers.get(workRef.name)
       });
       for (const line of checklist)
         console.log(`  ${pc.yellow("\u26A0")} ${line}`);
@@ -491,12 +499,12 @@ ${clearedMsg}`);
 }
 function resolveArchiveName(archiveSubdir, date, base) {
   const initialName = `${date}_${base}.md`;
-  if (!existsSync(join3(archiveSubdir, initialName)))
+  if (!archiveNameExists(archiveSubdir, initialName))
     return initialName;
   const MAX_SUFFIX = 9999;
   for (let index = 2; index <= MAX_SUFFIX; index++) {
     const candidate = `${date}_${base}-${index}.md`;
-    if (!existsSync(join3(archiveSubdir, candidate)))
+    if (!archiveNameExists(archiveSubdir, candidate))
       return candidate;
   }
   throw new WorkRefError(
@@ -505,6 +513,22 @@ function resolveArchiveName(archiveSubdir, date, base) {
     base
   );
 }
+function archiveNameExists(archiveSubdir, name) {
+  if (!existsSync(archiveSubdir))
+    return false;
+  return readdirSync(archiveSubdir).some((entry) => {
+    if (entry.normalize("NFC") !== name)
+      return false;
+    if (entry !== name) {
+      throw new WorkRefError(
+        "work_ref_collision",
+        `archive name has a Unicode normalization collision: ${entry} and ${name}`,
+        name
+      );
+    }
+    return true;
+  });
+}
 
 // src/commands/check.ts
 import { readFile as readFile4 } from "fs/promises";
@@ -696,8 +720,10 @@ async function runCheck(options = {}) {
         message: "missing YAML frontmatter"
       });
     }
+    const document = parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA);
     for (const section of requiredSections) {
-      if (!new RegExp(`^## ${section}$`, "m").test(content)) {
+      const definition = getDocumentSectionDefinitionByHeading(CHANGE_DOCUMENT_SCHEMA, section);
+      if (!definition || !getDocumentSections(document, definition.id).some((candidate) => candidate.canonical)) {
         addDiagnostic({
           severity: "error",
           code: "missing_section",
@@ -734,16 +760,14 @@ async function runCheck(options = {}) {
         });
       }
     }
-    const headingLine = content.split("\n").map((line) => line.trim()).find((line) => line.startsWith("# Change:"));
-    if (headingLine) {
-      const heading = headingLine.slice("# Change:".length).trim();
-      if (heading !== name) {
+    if (document.title !== null) {
+      if (document.title !== name) {
         addDiagnostic({
           severity: "error",
           code: "heading_mismatch",
           change: name,
           path: fp,
-          message: `# Change: heading "${heading}" differs from change name`
+          message: `# Change: heading "${document.title}" differs from change name`
         });
       }
     } else {
@@ -866,7 +890,7 @@ async function runCheck(options = {}) {
   return result;
 }
 function findUnfinishedTemplateLines(content) {
-  const placeholderRe = /<[^>\n]*(?:choose:|one-line|what |why |which |who |how |new |updated |expected |actual |specific |concrete |exact |verifiable |user |capability |behavior |context |action |path|directory|module|subsystem|command|scenario|constraint|requirement|question|uncertainty|implementation)[^>\n]*>/i;
+  const placeholderRe = /<(?:…|[^>\n]*(?:choose:|one-line|what |why |which |who |how |new |updated |expected |actual |specific |concrete |exact |verifiable |user |capability |behavior |context |action|path|directory|module|subsystem|command|scenario|constraint|requirement|question|uncertainty|implementation)[^>\n]*)>/i;
   return collectMatchingLines(content, (line) => {
     const trimmed = stripInlineCodeSpans(line).trim();
     return trimmed.startsWith("<!--") === false && placeholderRe.test(trimmed);
@@ -906,7 +930,7 @@ async function createChange(name, summary = "", kind, options = {}) {
       const existed = existsSync2(changePath);
       if (!existed) {
         const focusEntry = resolveFocusMarkerPath(workRef);
-        const content = generateChangeContent(name, summary, kind, { lite: Boolean(options.lite) });
+        const content = generateChangeContent(workRef.name, summary, kind, { lite: Boolean(options.lite) });
         await mkdir4(dirname2(changePath), { recursive: true });
         let changeCreated = false;
         try {
@@ -929,9 +953,9 @@ async function createChange(name, summary = "", kind, options = {}) {
       const label = existed ? "Using" : pc.green("Created");
       console.log(`  ${label}: ${changePath}`);
       if (existed)
-        console.log(`  ${pc.dim("Unchanged focus.")} Run: rsp focus ${name}`);
+        console.log(`  ${pc.dim("Unchanged focus.")} Run: rsp focus ${workRef.name}`);
       else
-        console.log(`  ${pc.dim("focused via focus.d")} \u2192 ${name}`);
+        console.log(`  ${pc.dim("focused via focus.d")} \u2192 ${workRef.name}`);
       console.log(`  ${pc.cyan("Next:")} ${options.lite ? "fill the lite change details, then implement and verify" : "fill proposal/spec/design first, then implement and complete the tasks"}
 `);
     });
@@ -1565,8 +1589,8 @@ async function focusChange(name) {
       await mkdir6(FOCUS_DIR, { recursive: true });
       await mkdir6(dirname3(focusEntry), { recursive: true });
       await writeManagedFile(focusEntry, "", "focus marker");
-      console.log(`  ${pc.green("Focused:")} ${name}`);
-      console.log(`  ${pc.dim("focus.d")} \u2192 ${name}`);
+      console.log(`  ${pc.green("Focused:")} ${workRef.name}`);
+      console.log(`  ${pc.dim("focus.d")} \u2192 ${workRef.name}`);
       console.log();
     });
   } catch (error) {
@@ -1587,8 +1611,8 @@ async function unfocusChange(name) {
         throw new WorkRefError("focus_marker_not_found", `.rsp/focus.d/${name}`, name);
       await unlink7(focusEntry);
       await cleanupEmptyParentDirs(focusEntry, FOCUS_DIR);
-      console.log(`  ${pc.green("Unfocused:")} ${name}`);
-      console.log(`  ${pc.dim("focus.d cleared")} \u2192 ${name}`);
+      console.log(`  ${pc.green("Unfocused:")} ${workRef.name}`);
+      console.log(`  ${pc.dim("focus.d cleared")} \u2192 ${workRef.name}`);
       console.log();
     });
   } catch (error) {
@@ -1623,20 +1647,21 @@ async function createChangeGroup(name, goal = "") {
       const ref = resolveWorkRef(`${name}/brief`);
       if (ref.kind !== "group-brief")
         throw new WorkRefError("invalid_work_ref", `invalid Change Group name: ${name}`, name);
-      if (await hasArchivedGroupBrief(name))
-        throw new ChangeGroupError(`archived Change Group cannot be reopened: ${name}`);
-      const groupDirectory = resolveManagedDirectoryChain(CHANGES_DIR, [name], "Change Group path");
+      const groupName = ref.group;
+      if (await hasArchivedGroupBrief(groupName))
+        throw new ChangeGroupError(`archived Change Group cannot be reopened: ${groupName}`);
+      const groupDirectory = resolveManagedDirectoryChain(CHANGES_DIR, [groupName], "Change Group path");
       await mkdir7(groupDirectory, { recursive: true });
       try {
-        await writeFile4(ref.path, generateGroupBriefContent(name, goal), { flag: "wx" });
+        await writeFile4(ref.path, generateGroupBriefContent(groupName, goal), { flag: "wx" });
       } catch (error) {
         if (error.code === "EEXIST")
-          throw new ChangeGroupError(`Change Group already exists: ${name}`);
+          throw new ChangeGroupError(`Change Group already exists: ${groupName}`);
         throw error;
       }
-      console.log(`  ${pc.green("Created Change Group:")} ${name}`);
+      console.log(`  ${pc.green("Created Change Group:")} ${groupName}`);
       console.log(`  ${pc.dim("Unfocused Group Brief:")} ${ref.path}`);
-      console.log(`  ${pc.cyan("Next:")} fill the brief, then create direct child Changes with rsp create ${name}/<change>
+      console.log(`  ${pc.cyan("Next:")} fill the brief, then create direct child Changes with rsp create ${groupName}/<change>
 `);
     });
   } catch (error) {
@@ -1659,12 +1684,13 @@ async function closeChangeGroup(name) {
       if (ref.kind !== "group-brief")
         throw new ChangeGroupError(`invalid Change Group name: ${name}`);
       const inspection = await inspectChangeGroups();
-      const group = inspection.groups.find((candidate) => candidate.name === name);
+      const groupName = ref.group;
+      const group = inspection.groups.find((candidate) => candidate.name === groupName);
       if (!group)
-        throw new ChangeGroupError(`Change Group not found: ${name}`);
-      const reasons = collectCloseReasons(group, inspection.diagnostics.filter((diagnostic) => diagnostic.change === name && diagnostic.severity === "error").map((diagnostic) => diagnostic.message));
+        throw new ChangeGroupError(`Change Group not found: ${groupName}`);
+      const reasons = collectCloseReasons(group, inspection.diagnostics.filter((diagnostic) => diagnostic.change === groupName && diagnostic.severity === "error").map((diagnostic) => diagnostic.message));
       if (reasons.length > 0)
-        throw new ChangeGroupError(`Change Group "${name}" is not ready to close: ${reasons.join("; ")}`);
+        throw new ChangeGroupError(`Change Group "${groupName}" is not ready to close: ${reasons.join("; ")}`);
       const archiveDirectory = resolveArchiveDirectory(ref);
       const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
       const archiveName = resolveArchiveName(archiveDirectory, date, "brief");
@@ -1676,7 +1702,7 @@ async function closeChangeGroup(name) {
       } catch (error) {
         warnings.push(`changes directory cleanup failed: ${toErrorMessage(error)}`);
       }
-      console.log(`  ${pc.green("Closed Change Group:")} ${name}`);
+      console.log(`  ${pc.green("Closed Change Group:")} ${groupName}`);
       console.log(`  ${pc.dim("Archived Group Brief:")} ${join7(archiveDirectory, archiveName)}
 `);
       for (const warning of warnings)
@@ -1712,8 +1738,6 @@ function collectCloseReasons(group, errors) {
 
 // src/commands/history.ts
 var DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
-var GROUP_RE = /^[a-z0-9-]+$/;
-var WORK_REF_RE = /^[a-z0-9-]+(?:\/[a-z0-9-]+)?$/;
 async function showHistory(input = {}, options = {}) {
   guardRspInitialized();
   const mode = input.workRef ? "detail" : "list";
@@ -1727,15 +1751,15 @@ async function showHistory(input = {}, options = {}) {
       message: "archive history inspection is incomplete; resolve the reported diagnostics before querying history"
     }, inspection.diagnostics, inspection.diagnosticSummary, inspection.runtime, options);
   }
-  if (input.workRef) {
+  if (validation.workRef) {
     try {
-      const selected = selectArchiveHistoryRecord(inspection.records, { workRef: input.workRef });
+      const selected = selectArchiveHistoryRecord(inspection.records, { workRef: validation.workRef });
       const record = await readArchiveHistoryDetail(selected);
       const result2 = {
         command: "history",
         ok: true,
         mode: "detail",
-        query: { workRef: input.workRef },
+        query: { workRef: validation.workRef },
         record,
         diagnostics: [],
         diagnosticSummary: emptyCollectionSummary(),
@@ -1788,11 +1812,15 @@ function validateHistoryQuery(input) {
   if ((input.positionalCount ?? (input.workRef ? 1 : 0)) > 1)
     return invalid("history_positional_args_unsupported", "history accepts at most one positional WorkRef");
   if (input.workRef) {
-    if (!WORK_REF_RE.test(input.workRef) || input.workRef.endsWith("/brief") || input.workRef.endsWith("/00-brief"))
+    let workRef;
+    try {
+      workRef = normalizeExecutableWorkRef(input.workRef);
+    } catch {
       return invalid("invalid_history_work_ref", "history WorkRef must be a flat or one-Group-level executable Change identity");
+    }
     if (input.limit !== void 0 || input.since !== void 0 || input.until !== void 0 || input.kind !== void 0 || input.group !== void 0 || input.search !== void 0)
       return invalid("history_detail_filters_unsupported", "list filters cannot be combined with an exact history detail lookup");
-    return { ok: true, query: {} };
+    return { ok: true, query: {}, workRef };
   }
   const limit = input.limit === void 0 ? HISTORY_DEFAULT_LIMIT : Number(input.limit);
   if (input.limit !== void 0 && !/^[1-9]\d*$/.test(input.limit) || !Number.isInteger(limit) || limit < 1 || limit > HISTORY_MAX_LIMIT)
@@ -1805,8 +1833,14 @@ function validateHistoryQuery(input) {
     return invalid("invalid_history_date_range", "--since must be on or before --until");
   if (input.kind !== void 0 && input.kind.trim() === "")
     return invalid("invalid_history_kind", "--kind must be a non-empty exact historical kind");
-  if (input.group !== void 0 && !GROUP_RE.test(input.group))
-    return invalid("invalid_history_group", "--group must be one lowercase kebab-case Group name");
+  let group = input.group;
+  if (group !== void 0) {
+    try {
+      group = normalizeWorkRefSegment(group);
+    } catch {
+      return invalid("invalid_history_group", "--group must be one safe Unicode Group name");
+    }
+  }
   if (input.search !== void 0 && input.search.trim() === "")
     return invalid("invalid_history_search", "--search must be non-empty");
   return {
@@ -1816,7 +1850,7 @@ function validateHistoryQuery(input) {
       since: input.since,
       until: input.until,
       kind: input.kind?.trim(),
-      group: input.group,
+      group,
       search: input.search?.trim()
     }
   };
@@ -1925,6 +1959,13 @@ function generateConfigTemplate() {
 # kinds:
 ${fmtList(VALID_KINDS, 0)}
 
+# Set one shared project default for durable artifact and commit prose.
+# Optional artifacts or commit values override that durable surface independently.
+# Response language remains user/session-owned and is never read from this project mapping.
+# Omit this mapping to keep durable language selection under scoped project authority.
+# language:
+#   default: en
+
 # New projects default to automatic Manage routing with lifecycle-only closeout.
 # Use activation: explicit to require a named managed request.
 # closeout accepts manual, lifecycle, or local; local routes a qualified clean terminal non-small boundary to one local commit but never push or publication.
@@ -2196,6 +2237,7 @@ async function reopenChange(name, options) {
   guardRspInitialized();
   try {
     await withRspLock("reopen-change", async () => {
+      const normalizedName = normalizeExecutableWorkRef(name);
       const inspection = await inspectArchiveHistory();
       if (!historyInspectionComplete(inspection)) {
         throw new ArchiveHistoryError(
@@ -2205,17 +2247,17 @@ async function reopenChange(name, options) {
       }
       const record = selectArchiveHistoryRecord(
         inspection.records,
-        options.from ? { path: options.from } : { workRef: name }
+        options.from ? { path: options.from } : { workRef: normalizedName }
       );
-      if (record.workRef !== name) {
+      if (record.workRef !== normalizedName) {
         throw new ArchiveHistoryError(
           "archive_identity_mismatch",
-          `selected archive belongs to ${record.workRef}, not ${name}`
+          `selected archive belongs to ${record.workRef}, not ${normalizedName}`
         );
       }
       let workRef;
       try {
-        workRef = resolveWorkRef(name, { executable: true });
+        workRef = resolveWorkRef(normalizedName, { executable: true });
       } catch (error) {
         if (error instanceof WorkRefError && error.code === "group_brief_missing") {
           throw new ArchiveHistoryError(
@@ -2232,8 +2274,8 @@ async function reopenChange(name, options) {
         throw new ArchiveHistoryError("focus_marker_exists", `focus marker already exists for non-open Change: ${name}; run rsp doctor`);
       const archivedContent = await readFile10(record.sourcePath, "utf-8");
       const reopenedContent = appendChecklistItem(
-        appendChecklistItem(archivedContent, "Tasks", `- [ ] Resolve reopened concern: ${reason}`),
-        "Verify",
+        appendChecklistItem(archivedContent, "tasks", `- [ ] Resolve reopened concern: ${reason}`),
+        "verify",
         `- [ ] Verify reopened concern: ${reason}`
       );
       await mkdir9(dirname4(workRef.path), { recursive: true });
@@ -2254,9 +2296,9 @@ async function reopenChange(name, options) {
         }
         throw error;
       }
-      console.log(`  ${pc.green("Reopened:")} ${name}`);
+      console.log(`  ${pc.green("Reopened:")} ${workRef.name}`);
       console.log(`  ${pc.dim("retained archive")} \u2192 ${record.path}`);
-      console.log(`  ${pc.dim("focused via focus.d")} \u2192 ${name}`);
+      console.log(`  ${pc.dim("focused via focus.d")} \u2192 ${workRef.name}`);
       console.log(`  ${pc.cyan("Next:")} refine the reopened Task and Verify evidence, then resolve the concern
 `);
       if (existsSync7(".git")) {
@@ -2280,21 +2322,18 @@ async function reopenChange(name, options) {
     throw error;
   }
 }
-function appendChecklistItem(content, heading, item) {
-  const headings = [...content.matchAll(new RegExp(`^## ${heading}[ \\t]*\\r?$`, "gm"))];
-  if (headings.length !== 1) {
+function appendChecklistItem(content, sectionId, item) {
+  try {
+    return appendDocumentSectionItem(parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA), sectionId, item);
+  } catch (error) {
+    if (!(error instanceof DocumentSectionCardinalityError))
+      throw error;
+    const heading = CHANGE_DOCUMENT_SCHEMA.sections.find((section) => section.id === sectionId).heading;
     throw new ArchiveHistoryError(
       "archive_section_invalid",
       `archived Change must contain exactly one required section: ${heading}`
     );
   }
-  const sectionBodyStart = headings[0].index + headings[0][0].length;
-  const nextHeading = content.indexOf("\n## ", sectionBodyStart);
-  const insertAt = nextHeading < 0 ? content.length : nextHeading;
-  const before = content.slice(0, insertAt);
-  const separator = before.endsWith("\n\n") ? "" : before.endsWith("\n") ? "\n" : "\n\n";
-  return `${before}${separator}${item}
-${content.slice(insertAt)}`;
 }
 
 // src/commands/show.ts
@@ -2488,6 +2527,7 @@ function deriveStatusView(snapshot, options = {}) {
   const nextActions = ok ? buildStatusNextActions(snapshot.focused.length, snapshot.records.map((record) => record.output), snapshot.groups, filtered) : ["Run: rsp doctor"];
   return {
     manage: snapshot.manage,
+    language: snapshot.language,
     query,
     focused: snapshot.focused,
     records,
@@ -2584,6 +2624,8 @@ function printStatusPlain(view) {
   console.log(`  ${pc.bold("RSP status")}`);
   console.log();
   console.log(`  ${pc.bold("Manage:")} activation ${view.manage.activation} \xB7 closeout ${view.manage.closeout}`);
+  if (view.language.artifacts !== null || view.language.commit !== null)
+    console.log(`  ${pc.bold("Language:")} artifacts ${view.language.artifacts ?? "unset"} \xB7 commit ${view.language.commit ?? "unset"}`);
   console.log();
   for (const diagnostic of view.diagnostics) {
     const label = diagnostic.change ?? diagnostic.path;
@@ -2703,6 +2745,7 @@ function toStatusJson(view) {
     command: "status",
     ok: view.ok,
     manage: view.manage,
+    language: view.language,
     filters: view.query,
     focused: view.focused,
     records: view.records.map((record) => record.output),
@@ -2720,6 +2763,7 @@ function toStatusJsonError(error, options) {
     command: "status",
     ok: false,
     manage: { activation: "explicit", closeout: "manual" },
+    language: { artifacts: null, commit: null },
     filters: {
       focused: options.focused,
       blocked: options.blocked,
@@ -3352,7 +3396,7 @@ async function runCli(rawArgs = process.argv.slice(2)) {
   if (shouldLaunchSkillsUi(rawArgs, terminalEnvironment)) {
     const { resolveUiLocale } = await import("./locale-HT44UIUP.mjs");
     const locale = resolveUiLocale("auto", process.env.RSP_UI_LANG, process.env.LC_ALL ?? process.env.LC_MESSAGES ?? process.env.LANG ?? new Intl.DateTimeFormat().resolvedOptions().locale);
-    const { runSkillsTui } = await import("./entry-WZDVKDUM.mjs");
+    const { runSkillsTui } = await import("./entry-5OPKUZHF.mjs");
     const selection = await runSkillsTui(locale);
     if (selection.kind === "confirmed") {
       const result = await installPackagedSkills({ names: selection.names, force: selection.force });
@@ -3370,7 +3414,7 @@ async function runCli(rawArgs = process.argv.slice(2)) {
     } else {
       const { resolveUiLocale } = await import("./locale-HT44UIUP.mjs");
       const locale = resolveUiLocale(lang, process.env.RSP_UI_LANG, process.env.LC_ALL ?? process.env.LC_MESSAGES ?? process.env.LANG ?? new Intl.DateTimeFormat().resolvedOptions().locale);
-      const { runTui } = await import("./entry-X23GPCVS.mjs");
+      const { runTui } = await import("./entry-FVUG6YW2.mjs");
       const exitCode = await runTui(locale);
       if (exitCode !== 0)
         process.exitCode = exitCode;

package/dist/{entry-WZDVKDUM.mjs → entry-5OPKUZHF.mjs}

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import {
   inspectPackagedSkillInventory
-} from "./chunk-NX55NIC3.mjs";
+} from "./chunk-D7XDXBFO.mjs";
 import {
   openTerminalSession,
   truncateDisplay
 } from "./chunk-JOMFFQRG.mjs";
-import "./chunk-OTJFL6XH.mjs";
+import "./chunk-FJVH7ZYU.mjs";
 
 // src/skills-tui/entry.tsx
 import process from "process";

package/dist/{entry-X23GPCVS.mjs → entry-FVUG6YW2.mjs}

@@ -7,14 +7,14 @@ import {
   projectDependencyForest,
   queryArchiveHistory,
   readArchiveHistoryDetail
-} from "./chunk-7KKAUBKN.mjs";
+} from "./chunk-FI3SYHVH.mjs";
 import {
   displayWidth,
   openTerminalSession,
   truncateDisplay,
   wrapDisplay
 } from "./chunk-JOMFFQRG.mjs";
-import "./chunk-OTJFL6XH.mjs";
+import "./chunk-FJVH7ZYU.mjs";
 
 // src/tui/entry.tsx
 import process from "process";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oevery/rsp",
   "type": "module",
-  "version": "3.1.0-beta.3",
+  "version": "3.1.0-beta.4",
   "description": "RSP (Reliable Software Practice), a repository-native engineering workflow for humans and AI agents",
   "author": "oevery",
   "license": "MIT",

package/rules/rsp-rules.md

@@ -18,7 +18,8 @@ This file is the minimal fallback protocol for agents that cannot load the `rsp`
 
 ## Core
 
-- Choose response language and artifact language independently. Localize response prose from the explicit request, scoped instructions, then conversation language; write authorized artifacts from the explicit request, scoped instructions, existing artifact language, then conversation language. Preserve canonical headings, WorkRefs, paths, commands, identifiers, and machine values.
+- Keep response language user/session-owned and durable project language repository-owned. For response prose, use an explicit current response language, user/host personal instructions, then conversation language; project `.rsp/config.yaml` never selects it. For a new authorized artifact, use an explicit artifact language, then the configured effective artifact language, artifact-scoped project instructions, and conversation language. Preserve an existing artifact's established language unless translation is explicitly authorized; changing configuration never rewrites it. Commit-message prose follows an explicit current commit-language instruction, configured effective commit language, nearest repository commit authority, then clear recent non-merge history. Preserve canonical headings, paths, commands, identifiers, Conventional Commit types/scopes, trailers, and machine values. WorkRefs follow the Unicode identity contract rather than the natural-language fallback chain.
+- Treat CLI-generated artifact scaffolds as deterministic structure, not natural-language generation: keep canonical structural tokens, neutral `<…>` placeholders, and verbatim user input; fill authorized prose from the effective artifact-language policy without a locale catalog or implicit English fallback.
 - Write persistent artifact prose in domain, system, user, or operator language. Mention AI or agents only when they are real product actors, consumers, interface participants, or constraints; agent authorship, execution narration, or convenience for a hypothetical future agent is not durable content.
 - `changes/` stores open work; `archives/` stores completed history; `specs/` stores stable current facts; the configured Decision Record path stores lasting rationale.
 - Every Change is one Markdown file with explicit `kind` and the fixed `Proposal`, `Spec`, `Design`, `Tasks`, `Verify`, and `Blockers` sections.
@@ -35,9 +36,9 @@ This file is the minimal fallback protocol for agents that cannot load the `rsp`
 - Persist only `open` and `archived`; readiness, blockers, verification, and next actions are derived.
 - When fresh evidence shows that an archived executable Change did not meet its original acceptance, explicitly use `rsp reopen <work-ref> --reason <text>` to restore the same WorkRef. Reopen retains the selected archive, focuses the open Change, and adds unfinished Task and Verify evidence. Multiple archives require exact `--from .rsp/archives/...` selection; open work wins over same-WorkRef history in current dependency state. Use a new corrective Change for genuinely new scope or an independently delivered correction. Do not reopen a closed Change Group implicitly.
 - Ordinary implementation is the default after unexplained failures are ruled out. Use test-first only when authority requires it or a concrete risk makes pre-mutation failure materially safer. Retain a new test only when it protects observable behavior or a real boundary with distinct proportionate value; otherwise remove the temporary probe and use decisive final verification.
-- Before later-turn mutation under a direct report, tiny, or small route, rederive from the newly authorized objective and prospective work. Cross-module implementation, multiple acceptance surfaces, repeated production-path correction, real-host validation, or lifecycle delivery requires the smallest sufficient WorkRef before mutation; unchanged tiny/small follow-ups stay direct. Elapsed time and message count alone never escalate work.
+- Before later-turn mutation under a direct report, design, tiny, or small route, rederive from the newly authorized objective and prospective work. Cross-module implementation, multiple acceptance surfaces, repeated production-path correction, real-host validation, bounded review convergence, lifecycle delivery, or a clear ready successor requires the smallest sufficient WorkRef and fresh qualification before mutation; unchanged tiny/small follow-ups stay direct. Elapsed time and message count alone never escalate work.
 - Before focusing or mutating a different WorkRef, compare dirty product or durable-truth paths with the prior owner's declared or observed paths. Overlap requires continuation of the same open WorkRef, an authorized reopen, an explicitly authorized integration owner, or a stop for boundary resolution. Disjoint authorized work may proceed without staging or forcing a commit; insufficient ownership evidence stops the transition.
-- This fallback does not emulate `rsp-manage`, even when project configuration selects automatic activation or local closeout. Invalid configuration grants nothing and remains visible. Every `manage.closeout` preset stays advisory because fallback Core never selects or qualifies Manage. For an explicit managed request or an automatically eligible completion/continuation, resolve the smallest owner using ordinary Core rules: reuse one unambiguous selected ready Change, send tiny settled work direct without a synthetic Change, and shape only independently authorized planning artifacts for clear non-trivial work. Configuration grants no planning or product-mutation authority. Stop for material product, acceptance, interface, scope, mutation, or external-action decisions. Perform at most one ordinary Core or Discipline action, return its WorkRef and next action, and never dispatch, auto-continue successors, loop review corrections, archive, stage, commit, push, or persist controller state. Load the `rsp` and `rsp-manage` Skills when controller behavior is required.
+- This fallback does not emulate `rsp-manage`, even when project configuration selects automatic activation or local closeout. Invalid configuration grants nothing and remains visible. Every `manage.closeout` preset stays advisory because fallback Core never selects or qualifies Manage. For an explicit managed request or an automatically eligible completion/continuation, resolve the smallest owner using ordinary Core rules: reuse one unambiguous selected ready Change, send tiny settled work direct without a synthetic Change, and shape only independently authorized planning artifacts for clear non-trivial work. Automatic eligibility includes independent slices, interruption recovery, or prospective execution spanning implementation plus integration/review/lifecycle, cross-module or cross-process mutation, real-host/provider/hardware verification, bounded finding convergence, or a clear ready successor. Decline as direct one-step work only when one owner, one local seam, one mutation pass, one decisive check, no managed lifecycle coordination, and no ready successor all hold; a selected ready completion or continuation that fails any one condition is non-small and requires loaded Manage rather than an unclassified fallback. Report that Manage is unavailable rather than selected, the decisive eligibility or exclusion, the exact direct action, and any applicable serial/parallel overlap reason; do not persist that reasoning. Configuration grants no planning or product-mutation authority. Stop for material product, acceptance, interface, scope, mutation, or external-action decisions. Perform at most one ordinary Core or Discipline action, return its WorkRef and next action, and never dispatch, auto-continue successors, loop review corrections, archive, stage, commit, push, or persist controller state. Load the `rsp` and `rsp-manage` Skills when controller behavior is required.
 - Route one explicit isolated domain, module/seam, or evidence-seeking question to installed `rsp-design`; use a compact manual design pass only when that Skill is unavailable. Without a selected Change, use report-only Pre-Change Design without inventing a WorkRef only when the question is already bounded; when outcome, scope, non-goals, acceptance, or decomposition remains materially unclear, route to Shape. With a selected Change, return evidence, alternatives, owner decisions, and any authorized planned-design update to the same WorkRef. Do not implement or write durable current truth from either mode.
 - Route release documentation only for an explicit release operation with a confirmed identity or range and unfinished surfaces; no Release Change is required. Confirm identity only from explicit instruction or authoritative configuration. Until then stay version-neutral and do not mutate versioned surfaces. Keep ledgers transient; use an optional Release Change only for material decisions, coordination, recovery, blockers, or acceptance. This route grants no Git, publication, deployment, or approval authority.
 - Do not infer current work from open Changes or filenames.

package/skills/rsp/SKILL.md

@@ -4,14 +4,14 @@ description: Use this skill when initializing RSP, operating an existing .rsp pr
 license: MIT
 metadata:
   author: oevery
-  version: "2026.07.28.1"
+  version: "2026.07.28.4"
 ---
 
 # RSP Skill
 
 Use RSP to derive one current action from project authority and durable work artifacts. This Skill is the preferred operational guide; `.rsp/rsp-rules.md` is the runtime fallback when the Skill is unavailable.
 
-Nearest project instructions and relevant `CONTEXT.md` remain authoritative. Choose response and artifact languages independently: localize human-facing response prose, but preserve canonical RSP headings, WorkRefs, paths, commands, identifiers, and machine values. Write persistent artifacts in domain, system, user, or operator language; mention AI or agents only when they are actual product actors or constraints.
+Nearest project instructions and relevant `CONTEXT.md` remain authoritative. Keep response language user/session-owned and durable project language repository-owned. Response prose follows an explicit current response language, user/host personal instructions, then conversation language; project `.rsp/config.yaml` never selects it. A new authorized artifact follows an explicit artifact language, then the configured effective artifact language, artifact-scoped project instructions, and conversation language; an existing artifact keeps its established language unless translation is explicitly authorized. Configuration changes never rewrite existing artifacts. Commit-message prose follows an explicit current commit-language instruction, configured effective commit language, nearest repository commit authority, then clear recent non-merge history. Preserve canonical headings, paths, commands, identifiers, Conventional Commit types/scopes, trailers, and machine values; WorkRefs follow the Unicode identity contract rather than the natural-language fallback chain. Write persistent artifacts in domain, system, user, or operator language; mention AI or agents only when they are actual product actors or constraints.
 
 ## Scope
 
@@ -23,7 +23,7 @@ Read user intent, nearest authority, `rsp status --json`, the selected Change an
 
 Apply these routes in order:
 
-Before later-turn mutation under a direct report, tiny, or small route, rederive routing from the now-authorized objective and prospective work. If it materially expands into cross-module implementation, multiple acceptance surfaces, repeated production-path correction, real-host validation, or lifecycle delivery, establish or reuse the smallest sufficient WorkRef, then apply managed preflight and fresh qualification before mutation. Follow-ups that remain tiny/small stay direct. Elapsed time and message count are never escalation evidence.
+Before later-turn mutation under a direct report, design, tiny, or small route, rederive routing from the now-authorized objective and prospective work. If it materially expands into cross-module implementation, multiple acceptance surfaces, repeated production-path correction, real-host validation, bounded review convergence, lifecycle delivery, or a clear ready successor, establish or reuse the smallest sufficient WorkRef, then apply managed preflight and fresh qualification before mutation. Follow-ups that remain tiny/small stay direct. Elapsed time and message count are never escalation evidence.
 
 1. Stop for ambiguous authority or selection and return the one required input and its owner. For a material owner decision inside an explicit managed request, continue to the Shape preflight in route 2 so repository inspection precedes the single owner question; otherwise stop here.
 2. For a requested completion or continuation that is not a report-only review or release operation, read [managed routing](references/managed-routing.md) when the request is explicitly managed or the effective status policy has `manage.activation: auto`. It owns owner preflight, qualification, successor discovery, bounded review convergence, and lifecycle/Git separation. Select `rsp-manage` only after that preflight for an eligible selected ready Change or shallow Group; otherwise return the ordinary Core or Discipline action. Automatic activation grants controller selection only; planning, product mutation, lifecycle, Git, and external authority remain separately derived.
@@ -35,7 +35,7 @@ Before later-turn mutation under a direct report, tiny, or small route, rederive
 8. For incomplete implementation or stale, missing, or failed verification, use [Implementation evidence](#implementation-evidence).
 9. When Tasks and required verification pass without blockers, perform the durable decision. Do not infer a release operation from Change completion.
 
-State the derived stage, one next action, required input, returned owner, and decisive evidence. Name at most one optional capability, only when it is the next action and appears in the host's loaded Skill inventory. Missing capabilities never invalidate RSP: give the manual fallback against the same owner. When Core or qualified Manage has derived one authorized RSP-owned local commit boundary, route exact staging, structured message construction, local commit execution, and post-commit observation to `rsp-commit`; if unavailable, use the bounded manual action in durable review against the same owner. Do not preload, enumerate, or recursively invoke optional capabilities.
+State the derived stage, one next action, required input, returned owner, and decisive evidence. When managed routing is evaluated, state `selected` or `declined` with the decisive qualification signal or complete direct-work exclusion; when dispatch applies, also state why it is parallel or sequential. Name at most one optional capability, only when it is the next action and appears in the host's loaded Skill inventory. Missing capabilities never invalidate RSP: give the manual fallback against the same owner. When Core or qualified Manage has derived one authorized RSP-owned local commit boundary, route exact staging, structured message construction, local commit execution, and post-commit observation to `rsp-commit`; if unavailable, use the bounded manual action in durable review against the same owner. Do not preload, enumerate, or recursively invoke optional capabilities.
 
 ### Implementation evidence
 

package/skills/rsp/references/managed-routing.md

@@ -13,13 +13,17 @@ Before focusing, dispatching, or mutating a different WorkRef, inspect dirty pat
 - For clear non-trivial work with no sufficient ready owner, an explicit managed request authorizes only in-scope RSP planning artifacts unless the user requests no edits. Under automatic activation, route to Shape only when the current request or nearer authority independently permits those artifacts; configuration alone never does. Then re-read status/readiness and re-evaluate without another authorization round.
 - If repository evidence leaves a material product, acceptance, public-interface, scope, mutation-authority, external-action, or human choice, Shape returns the single highest-impact owner decision and creates no implementation or controller artifact.
 
-A prior direct report, tiny, or small route is not sticky. Before later-turn mutation, rederive from the now-authorized objective and prospective work. Material expansion into cross-module implementation, multiple acceptance surfaces, repeated production-path correction, real-host validation, or lifecycle delivery requires Core to establish or reuse the smallest sufficient WorkRef and rerun this preflight plus fresh Manage qualification before mutation. Unchanged tiny/small follow-ups remain direct; elapsed time and message count alone never trigger escalation.
+A prior direct report, design, tiny, or small route is not sticky. Before later-turn mutation, rederive from the now-authorized objective and prospective work. Material expansion into cross-module implementation, multiple acceptance surfaces, repeated production-path correction, real-host validation, bounded review convergence, lifecycle delivery, or a clear ready successor requires Core to establish or reuse the smallest sufficient WorkRef and rerun this preflight plus fresh Manage qualification before mutation. Unchanged tiny/small follow-ups remain direct; elapsed time and message count alone never trigger escalation.
 
 PREFLIGHT is complete only when one selected ready Change or shallow Group owns the requested outcome and no material decision remains.
 
 ## QUALIFY — select or decline Manage
 
-Select `rsp-manage` only for one selected ready Change or shallow Group that qualifies through at least one independent path: genuinely independent slices, prospectively long authorized continuation, or interruption recovery. A Change with long/recovery work does not also need independent or parallelizable slices. Derive “long” before dispatch from the authorized objective and its expected phases; elapsed wall-clock minutes are never qualification evidence. Small coupled one-step work and worker-only work remain ineligible and return to ordinary Core or Discipline action. Automatic routing is policy-selected, bounded by the requested goal, and not inferred from readiness alone.
+Select `rsp-manage` only for one selected ready Change or shallow Group that qualifies through at least one independent path: genuinely independent slices, interruption recovery, or prospective execution signals showing more than one bounded phase or authority surface. Prospective signals are implementation followed by integration verification, managed review, or lifecycle work; cross-module or cross-process mutation; real-host, provider, or hardware verification; bounded finding convergence; or a clear ready successor. A Change with prospective or recovery work does not also need independent or parallelizable slices. Derive these signals before dispatch from the authorized objective and expected phases; elapsed wall-clock minutes are never qualification evidence.
+
+Under automatic activation, bias non-small continuation toward Manage. Decline as direct one-step work only when all of these are true: one owner, one local seam, one mutation pass, one decisive check, no managed lifecycle coordination, and no ready successor. A selected ready completion or continuation that fails any one of these conditions qualifies as non-small through this automatic path even when no separate prospective signal is obvious; do not leave the middle case unclassified. Worker-only work remains ineligible. Readiness alone does not qualify work without a requested completion or continuation, and automatic routing remains bounded by the requested goal.
+
+Make the route observable: report `selected` with the decisive qualification signal, or `declined` with the complete direct-work exclusion and exact Core or Discipline action. If dispatch applies, report the concrete overlap/isolation evidence that makes it sequential or parallel. Selection, decline, and dispatch reasoning remain transient and create no controller state.
 
 ## CONTINUE — rederive from evidence
 

package/skills/rsp-commit/SKILL.md

@@ -4,7 +4,7 @@ description: Create one authorized, exact-scope local commit for an RSP-owned Ch
 license: MIT
 metadata:
   author: oevery
-  version: "2026.07.26.1"
+  version: "2026.07.28.2"
 ---
 
 # RSP Commit
@@ -19,7 +19,7 @@ Stop without staging when the owner, allowed paths, commit authority, verificati
 
 ## Derive the message
 
-Choose subject language from explicit current instruction, then nearest repository authority, then the clear style of recent non-merge commits. Response language, RSP artifact language, and preferences remembered from another repository do not select it. When recent history is materially mixed and no nearer rule resolves it, return the single language decision to its owner.
+Choose subject and body prose language from explicit current commit-language instruction, then the configured effective commit language, nearest repository commit authority, and finally the clear style of recent non-merge commits. Response language and preferences remembered from another repository do not select it. Preserve Conventional Commit types/scopes and trailers as technical values. When recent history is materially mixed and no nearer rule resolves it, return the single language decision to its owner.
 
 Use the repository's established Conventional Commit form when present. Derive type and scope from the owned outcome and repository history, not from the conversation. Keep the subject concise and imperative or otherwise repository-consistent.