@try-works/dsh-recursive-mode 0.4.2 → 0.4.4

package/src/memory-feedback.ts

@@ -19,7 +19,32 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
 import { dirname, join } from 'node:path'
 
 /** Where the machine-owned counters live — inside the memory plane, but never a shard a person writes. */
-export const FEEDBACK_FILE = 'memory/.feedback.json'
+// The path is `.recursive/memory/.feedback.json`, joined onto the REPO ROOT, which is what the
+// doc comment above has always said and what `filterRuntimeChangedFiles` expects: a counter the
+// memory plane writes must live inside the `.recursive` control plane, not in the product tree.
+// Measured before this fix: a completed fixture run ended with four residual FAILs naming
+// `memory/.feedback.json` against phases 03 and 03.5, because the file landed outside
+// `.recursive/run/<runId>/`, survived the runtime-diff filter, and entered the run's diff only
+// after those phases were authored - retro-invalidating them. The counter is machine-owned and
+// disposable per the same doc comment, so a counter left at the OLD path by an earlier version is
+// READ once (see LEGACY_FEEDBACK_FILE) rather than silently dropped.
+export const FEEDBACK_FILE = '.recursive/memory/.feedback.json'
+
+/**
+ * WHERE THE COUNTERS LIVED BEFORE the constant above carried its `.recursive/` prefix.
+ *
+ * ⚠ READ, BUT DELIBERATELY NEITHER MOVED NOR DELETED. Read, because evidence a previous run recorded is
+ * not the plugin's to discard, and without the fallback the first settle after the move would start the
+ * new file from an empty book — a counter lost silently, which is the one outcome ruled out. NOT moved,
+ * because a delete is the single action that could re-create the very defect the prefix fixes: a legacy
+ * file that is TRACKED and COMMITTED is absent from the run's diff while it is clean, so removing it
+ * mid-run puts `D memory/.feedback.json` into the diff of every diff-audited phase authored before the
+ * delete, which is the same retro-invalidation. Left alone, an untracked legacy file is in the diff from
+ * the run's first phase (and is therefore accounted for), while a committed one stays invisible.
+ * `readFeedback` prefers {@link FEEDBACK_FILE}, so the legacy counters are folded forward by the next
+ * settle and this file then only sits there; it is machine-owned and disposable, so delete it by hand.
+ */
+export const LEGACY_FEEDBACK_FILE = 'memory/.feedback.json'
 
 /** Where a run records what it was shown. */
 export const INJECTIONS_FILE = 'memory-injections.json'
@@ -43,10 +68,24 @@ export interface FeedbackCounter {
 
 export type FeedbackBook = Record<string, FeedbackCounter>
 
-/** Read the counters. A missing or unreadable file is an empty book, never an error. */
+/**
+ * Read the counters. A missing or unreadable file is an empty book, never an error.
+ *
+ * ⚠ THE LEGACY PATH IS A FALLBACK AND ONLY A FALLBACK: it is consulted when — and only when — there is
+ * no usable file at {@link FEEDBACK_FILE} yet, which is exactly the first run after the path moved. The
+ * two are never merged, because they are two SNAPSHOTS of one counter and adding them would count a run
+ * twice. A file that exists at the current path but does not parse stays an empty book, which is what
+ * this function has always promised: a corrupt sidecar is not an invitation to read a different file.
+ */
 export function readFeedback(root: string, readFile: (path: string) => string | null = defaultRead): FeedbackBook {
-  const text = readFile(join(root, FEEDBACK_FILE))
-  if (text === null || text.trim() === '') return {}
+  const current = readFile(join(root, FEEDBACK_FILE))
+  if (current !== null && current.trim() !== '') return parseBook(current)
+  const legacy = readFile(join(root, LEGACY_FEEDBACK_FILE))
+  return legacy === null ? {} : parseBook(legacy)
+}
+
+/** One counters file as a book: anything unreadable or unshaped is `{}`, never an error. */
+function parseBook(text: string): FeedbackBook {
   try {
     const parsed = JSON.parse(text) as unknown
     if (typeof parsed !== 'object' || parsed === null) return {}
@@ -140,7 +179,13 @@ export function settleInjections(
     book[record.source] = counter
   }
 
-  write(join(root, FEEDBACK_FILE), JSON.stringify(sortBook(book), null, 2) + '\n')
+  const feedbackPath = join(root, FEEDBACK_FILE)
+  // The counter now lives under the `.recursive` control plane, whose memory directory a fresh
+  // checkout or a scratch fixture may not have yet. Creating it here rather than assuming it
+  // exists is what a plugin owning its own control plane should do; before this, the write
+  // threw ENOENT when nothing else had already made the directory.
+  mkdirSync(dirname(feedbackPath), { recursive: true })
+  write(feedbackPath, JSON.stringify(sortBook(book), null, 2) + '\n')
   return book
 }
 

package/src/phase-rules.ts

@@ -490,7 +490,16 @@ export function resolveFrom(worktreeRoot: string, target: string): string | null
   const normalized = target.replace(/\\/g, '/').trim()
   if (!normalized) return null
   if (/^[A-Za-z]:\//.test(normalized) || normalized.startsWith('/')) return resolve(normalized)
-  return resolve(join(worktreeRoot, normalized.replace(/^\.?\/?/, '')))
+  // ⚠ FIX 2 — THIS USED TO STRIP A LEADING DOT, WHICH IS NOT THE SAME AS STRIPPING `./`.
+  //
+  // The regex was `/^\.?\/?/`: an optional dot followed by an optional slash. Its intent was plainly to normalise a
+  // `./relative` path, but on a DOTFILE path it removed the dot and kept the name — so `.recursive/run/<id>/01.md`
+  // resolved to `<root>/recursive/run/<id>/01.md`, OUTSIDE the run tree it names. Under strict enforcement the phase
+  // guard denies writes outside the run tree, and a live verification pass recorded five denials out of five while
+  // trying to author phase artifacts — the model could not write the very files the workflow is about.
+  //
+  // Only `./` is a relative-path prefix. A bare leading dot is part of the name.
+  return resolve(join(worktreeRoot, normalized.replace(/^\.\//, '')))
 }
 
 /** The tool-target path of a call (same key order enforcement.ts uses). */

package/src/policy-globs.ts

@@ -419,14 +419,36 @@ function lockOrderRule(artifact: unknown, runDir: string | undefined): ToolPolic
 /**
  * Locked-artifact write rule: a denial when the target carries
  * `Status: LOCKED`, `null` otherwise. Only a run-tree `*.md` is a candidate —
- * the same admission test the pre-T16 branch used.
+ * the same admission test the pre-T16 branch used, now asked of the RESOLVED
+ * path as well (see the ADMISSION note below).
+ *
+ * A caller with no `worktreeRoot` still gets `null` for every target, absolute
+ * ones included: that is the pre-existing behaviour and it is left alone here —
+ * the guard always carries a root, so nothing that reaches it changes.
  */
 function lockedWriteRule(target: string | null, worktreeRoot: string | undefined): ToolPolicyPredicateMatch | null {
   if (!target || !worktreeRoot) return null
   const normalized = target.replace(/\\/g, '/')
-  if (!normalized.endsWith('.md') || !normalized.includes('/.recursive/run/')) return null
+  if (!normalized.endsWith('.md')) return null
   const abs = resolveFrom(worktreeRoot, normalized)
-  if (!abs || getLockStatus(abs) !== 'LOCKED') return null
+  if (!abs) return null
+  // ADMISSION — a target is a candidate when it NAMES the run tree, and the marker is
+  // looked for on the path the target RESOLVES to as well as on the string as written.
+  //
+  // The string test alone requires a separator BEFORE `.recursive`, so it admitted an
+  // ABSOLUTE target and missed a REPO-RELATIVE one (`.recursive/run/<id>/00-requirements.md`,
+  // the form a model actually types, and its backslash spelling too). The rule then
+  // ABSTAINED, the phase baseline saw a write INSIDE the run tree — allowed by design — and
+  // the catch-all allowed a write to an artifact whose `Status:` is LOCKED. The resolved test
+  // is the fix, and it is the same question asked of the path the string names; `getLockStatus`
+  // below already used `abs`, so the two halves of this rule now agree on one path.
+  //
+  // The string test is KEPT rather than replaced, so that no absolute spelling denied today
+  // becomes allowed: a literal target that carries the marker but resolves away from it
+  // (`…/.recursive/run/../…`) is still admitted, exactly as before.
+  const resolved = abs.replace(/\\/g, '/')
+  if (!normalized.includes('/.recursive/run/') && !resolved.includes('/.recursive/run/')) return null
+  if (getLockStatus(abs) !== 'LOCKED') return null
   return { verdict: 'deny', detail: normalized + ' carries Status: LOCKED (reopen explicitly to edit)' }
 }
 

package/src/policy-write.ts

@@ -18,7 +18,7 @@
  *    present-but-empty value would stop the deferral and pin the choice to nothing, which is a different state
  *    from "unconfigured" and not one a user can see. Absence is the honest representation of "I have no opinion".
  *
- * 3. **WRITE ATOMICALLY.** A temp file and a rename, the same pattern the preset installer uses. A policy file
+ * 3. **WRITE ATOMICALLY.** A temp file and a rename, the same pattern the preset installer used, before it was retired. A policy file
  *    half-written because a process died mid-write would make `loadRouterPolicy` fall back to the built-in
  *    self-audit policy — and it does that SILENTLY, on purpose (it never throws). So a torn write here would look
  *    exactly like "the user configured nothing", for every role, until someone read the file.

package/src/runtime.ts

@@ -1470,6 +1470,35 @@ export class RecursiveRuntime extends Service {
     if (inFlight.length > 0) {
       throw new Error(toolError('PENDING_WORK', inFlight.map((p) => p.detail).join('; ')))
     }
+    // README §4.1 — THE STANDARD GATE. `recursive_lock` promises that it "refuses
+    // if the artifact does not meet the standard", and until this gate existed it
+    // checked existence, re-lock, lock ORDER and quiescence and never consulted the
+    // linter, so a 14-FAIL artifact locked cleanly and its receipt certified work no
+    // check had accepted. The linter is the authority on the standard, so the same
+    // entry point the `recursive_lint` tool calls is consulted here.
+    //
+    // PLACED LAST among the refusals, immediately before the LOCKED-fields mutation:
+    // every cheaper refusal keeps its existing precedence, and in particular LOCK
+    // ORDER STAYS FIRST — a run that is both out of order AND below standard still
+    // reports ordering, exactly as it did before this gate. The already-LOCKED check
+    // and the `reopen` branch precede this point too, so nothing previously locked is
+    // disturbed and reopen does not suddenly demand a standard it never had.
+    //
+    // A plain `Error`, in the same style as the refusals above, rather than a new
+    // `toolError` code: no registry entry describes "below the phase standard", and
+    // inventing one would add a code `tests/errors.spec.ts` has to be taught, for a
+    // refusal whose remedy is the FAIL list it already carries.
+    //
+    // CONSERVATIVE WHEN THE LINT CANNOT RUN: a lint whose job was killed or failed
+    // returns `passed: false` with the reason in `errors`, so an artifact that could
+    // not be checked is refused rather than waved through — "not measured" is not
+    // "meets the standard".
+    const lint = await this.lintArtifact(runId, artifact, agent)
+    if (!lint.passed) {
+      throw new Error(
+        'Artifact ' + artifact + ' does not meet the phase standard, so it was not locked: ' + lint.errors.join('; '),
+      )
+    }
     let content = readFileSync(artifactPath, 'utf8')
     const lockedAt = new Date().toISOString().replace(/\.\d{3}Z$/, 'Z')
     content = setOrInsertField(content, 'Status', 'LOCKED', ['Phase'])