devflow-kit 3.9.0 → 3.11.0

package/dist/core/flags.js

@@ -441,8 +441,8 @@ export const FLAG_REGISTRY = [
     {
         // D-FOREGROUND-RUN: every agent runs builds and tests in the foreground under an explicit
         // Bash `timeout` whose ceiling is Claude Code's 600000 ms, or this variable when set. A
-        // suite that cannot be split under that ceiling is reported BLOCKED with the remedy
-        // `devflow flags --set bash-max-timeout-ms=<ms>`, so this flag is that remedy.
+        // run that passes its timeout is waited for and read, so raising the ceiling is optional:
+        // it only lets a long run end inside one call.
         // The env name was confirmed against Claude Code 2.1.294 (docs/reference/claude-code-flags-probe.md):
         // the binary reads BASH_MAX_TIMEOUT_MS, ignores a non-positive or NaN value, and takes the
         // larger of it and the default timeout. Neutral by default (undefined → manifest null →

package/dist/core/fs-atomic.js

@@ -10,6 +10,10 @@ import { promises as fs } from 'fs';
  * intentionally remains a separate implementation — same semantics, different module
  * system. Any change to the retry logic here MUST be mirrored there.
  */
+/** The sibling `filePath` is written to before the rename: `<file>.tmp.<pid>`. */
+export function atomicTempPath(filePath) {
+    return `${filePath}.tmp.${process.pid}`;
+}
 /**
  * Atomically write `filePath` by writing to a sibling `.tmp` then renaming.
  *
@@ -38,7 +42,7 @@ export async function writeFileAtomicExclusive(filePath, data, createMode) {
     // (e.g., two Claude Code sessions) never collide on the same .tmp path.
     // mirrors proxy-log.ts rotation at src/core/proxy-log.ts which PID-scopes
     // for the same reason.
-    const tmp = `${filePath}.tmp.${process.pid}`;
+    const tmp = atomicTempPath(filePath);
     const options = { encoding: 'utf-8', flag: 'wx', ...(createMode === undefined ? {} : { mode: createMode }) };
     try {
         await fs.writeFile(tmp, data, options);

package/dist/core/installed-variants.js

@@ -0,0 +1,63 @@
+/**
+ * The install record of the prompt variants (#648, AC-29 and AC-31).
+ *
+ * After a converge that finished clean, the manifest records which variant of each axis the
+ * installed prompts hold: `installedVariants: { curation, compliance }`. The record is the only
+ * way to tell what is installed without reading every prompt, and it answers one question the
+ * switches alone cannot: does this machine still carry posting steps from before the switch moved?
+ *
+ * The manifest reader carries the field raw, so a hand-edited or newer-version value reaches this
+ * module unchecked. {@link readInstalledVariants} is the one parse: anything but two booleans is
+ * unknown, and an absent field is unknown. Nothing heals an unknown record. Pure, with no I/O.
+ */
+/** The record as the manifest carries it, or null when it is absent or is not two booleans (unknown). */
+export function readInstalledVariants(raw) {
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
+        return null;
+    const { curation, compliance } = raw;
+    if (typeof curation !== 'boolean' || typeof compliance !== 'boolean')
+        return null;
+    return { curation, compliance };
+}
+/**
+ * The record to write for a converge, or null when none is owed (AC-29). Only a converge that
+ * finished clean records the switches the prompts were converged onto. Any other converge writes
+ * nothing, so the field is left out and reads as unknown: it names `devflow init`, and the posting
+ * notice stays due. Pure; the result is a fresh object.
+ */
+export function installRecordFor(converged, switches) {
+    return converged ? { curation: switches.curation, compliance: switches.compliance } : null;
+}
+/**
+ * Whether the posting steps are installed, from the record and the machine's compliance switch.
+ *
+ * `installed` and `not installed` are the two settled states: the record agrees with the switch, and
+ * the on variant carries the posting steps while the off variant carries none. A record that
+ * disagrees with the switch is `mismatch`, and a record that is absent or unreadable is `unknown`;
+ * both name the remedy.
+ */
+export function postingStatus(installed, complianceEnabled) {
+    if (installed === null)
+        return 'unknown (run devflow init)';
+    if (installed.compliance !== complianceEnabled)
+        return 'mismatch (run devflow init)';
+    return complianceEnabled ? 'installed' : 'not installed';
+}
+/** What `devflow init` prints, once, when the installed prompts move from posting steps to none. */
+export const POSTING_OFF_NOTICE = 'Compliance is off on this machine, so devflow installed no step that posts test-plan evidence, ' +
+    'review or resolution summaries, backlog entries, review-thread replies, wave reports, plan artifacts ' +
+    'or release back-links to GitHub or a tracker. Results stay in local files under .devflow/docs/. ' +
+    'To install these steps, run `devflow compliance --enable`.';
+/**
+ * Whether init owes the posting notice: compliance is off and the record does not already say the
+ * installed prompts carry no posting step. A record that is absent or unreadable is unknown, and
+ * unknown counts as posting, so a machine from before the record existed hears the notice once.
+ * The caller also requires a clean converge and a written record, so the notice and the record
+ * move together and the next init finds the record and stays quiet.
+ */
+export function postingNoticeDue(installed, complianceEnabled) {
+    if (complianceEnabled)
+        return false;
+    return installed === null || installed.compliance;
+}
+//# sourceMappingURL=installed-variants.js.map

package/dist/core/manifest.js

@@ -210,6 +210,9 @@ export async function readManifest(devflowDir, opts) {
             },
             installedAt: data.installedAt,
             updatedAt: data.updatedAt,
+            // The install record of the prompt variants, raw (see the field's doc comment). Last, where
+            // the writer that records it puts it, so a read and a write never move the key.
+            ...(Object.hasOwn(data, 'installedVariants') ? { installedVariants: data.installedVariants } : {}),
         };
         if (needsHeal) {
             // D39: wrap the heal-write in its own try/catch so a write failure does NOT
@@ -293,7 +296,8 @@ export async function syncManifestFeature(devflowDir, key, value) {
  * re-init install it again. Going through readManifest()/writeManifest() instead
  * would drop every key ManifestData does not model (one a newer devflow wrote,
  * say) and persist that reader's unrelated heals as a side effect of a removal.
- * Entries that are not strings are neither matched nor dropped.
+ * Entries that are not strings are neither matched nor dropped. A legacy name matches its current plugin
+ * ({@link doomedEntryTest}).
  */
 export function withoutManifestPlugins(rawManifest, names, now) {
     if (typeof rawManifest !== 'object' || rawManifest === null || Array.isArray(rawManifest))
@@ -301,12 +305,25 @@ export function withoutManifestPlugins(rawManifest, names, now) {
     const record = rawManifest;
     if (!Array.isArray(record.plugins))
         return null;
-    const doomed = new Set(names);
-    const kept = record.plugins.filter(entry => !(typeof entry === 'string' && doomed.has(entry)));
+    const isDoomed = doomedEntryTest(names);
+    const kept = record.plugins.filter(entry => !(typeof entry === 'string' && isDoomed(entry)));
     if (kept.length === record.plugins.length)
         return null;
     return { ...record, plugins: kept, updatedAt: now };
 }
+/**
+ * Whether a recorded plugin name is one of `names`, a legacy name counting as its current plugin on both sides.
+ * Removing `devflow-plan` therefore also drops a record that still holds `devflow-specify`. Any other name,
+ * a name the registry does not know included, matches only itself.
+ *
+ * The record is file content, so only a key LEGACY_PLUGIN_NAMES owns maps; one it inherits from Object,
+ * such as `constructor`, is an ordinary name.
+ */
+function doomedEntryTest(names) {
+    const current = (name) => (Object.hasOwn(LEGACY_PLUGIN_NAMES, name) ? LEGACY_PLUGIN_NAMES[name] : name);
+    const doomed = new Set(names.map(current));
+    return entry => doomed.has(current(entry));
+}
 /**
  * D-UNINSTALL-DROPS-PLUGIN: record a selective uninstall in `<devflowDir>/manifest.json`.
  *
@@ -339,9 +356,35 @@ export async function removeManifestPlugins(devflowDir, names) {
     catch (error) {
         return { ok: false, error: error instanceof Error ? error.message : String(error) };
     }
-    const doomed = new Set(names);
+    const isDoomed = doomedEntryTest(names);
     const before = raw.plugins;
-    return { ok: true, removed: before.filter((entry) => typeof entry === 'string' && doomed.has(entry)) };
+    return { ok: true, removed: before.filter((entry) => typeof entry === 'string' && isDoomed(entry)) };
+}
+/**
+ * The plugin names `<devflowDir>/manifest.json` records as installed, or null when there is no usable record.
+ * Read only: unlike {@link readManifest} it never heals, never takes the manifest lock and writes nothing, so
+ * the file stays byte-identical. That is the property a selective uninstall needs. Its caller works from the
+ * record as `removeManifestPlugins` does, and a heal would rewrite a manifest the uninstall did not mean to
+ * touch (and write through a link in a legacy local install).
+ *
+ * A record is a manifest {@link readManifest} would accept: valid JSON that holds every required field.
+ * Anything else is null, never an empty list, so a caller can tell "nothing recorded" from "nothing
+ * installed". Entries that are not strings are skipped.
+ */
+export async function readManifestPlugins(devflowDir) {
+    let raw;
+    try {
+        raw = JSON.parse(await fs.readFile(path.join(devflowDir, 'manifest.json'), 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
+        return null;
+    const record = raw;
+    if (!hasRequiredManifestFields(record))
+        return null;
+    return record.plugins.filter((entry) => typeof entry === 'string');
 }
 /**
  * Merge new plugins into existing plugin list (union, no duplicates).