@try-works/dsh-recursive-mode 0.6.0 → 0.6.1

package/lib/index.js

@@ -2071,34 +2071,55 @@ const SECTION_MAP = {
 * field the plane's own linter already requires, so the artifact shape stays canonical.
 */
 const PHASE8_MEMORY_ARTIFACT = "08-memory-impact.md";
+/** The plane, repo-relative. The trailing slash is what every guard here tests for. */
+const MEMORY_PLANE_PREFIX = ".recursive/memory/";
+/** The canonical section the declaration goes in — present in every scaffolded phase-8 artifact. */
+const PHASE8_MEMORY_SECTION = "Affected Memory Docs";
+/**
+* Where a durable doc may be filed, and the `Type` the memory-plane linter requires for it.
+*
+* ⚠ EVERY `dir` IS THE REAL PLANE, `.recursive/memory/…`, AND NOT A `memory/…` RELATIVE FORM. Measured:
+* `bootstrap.ts` scaffolds the plane under `.recursive/`, `ts-lint.ts` lints it there, and the phase-8
+* artifact cites it there — while the training trigger's own write seam joins its `memory/…` paths onto
+* the workspace root, i.e. `<root>/memory/`, a directory that exists in no real workspace (the reader
+* side of that defect was fixed in `memory.ts`; the writer side is `runtime.ts`'s seam and is reported,
+* not edited). This table names the location a WRITE must land in, so it names the plane.
+*
+* ⚠ `skill` SHARES `pattern`'s Type ON PURPOSE: `/.recursive/memory/skills/patterns/` is where a
+* promoted skill lesson ships (`bootstrap.ts` scaffolds three docs there), and the linter's allowed
+* Types are `index|domain|pattern|incident|episode` — there is no `skill` Type to declare.
+*/
+const MEMORY_DOC_LOCATIONS = {
+	domain: {
+		dir: ".recursive/memory/domains",
+		type: "domain"
+	},
+	pattern: {
+		dir: ".recursive/memory/patterns",
+		type: "pattern"
+	},
+	incident: {
+		dir: ".recursive/memory/incidents",
+		type: "incident"
+	},
+	episode: {
+		dir: ".recursive/memory/episodes",
+		type: "episode"
+	},
+	skill: {
+		dir: ".recursive/memory/skills/patterns",
+		type: "pattern"
+	}
+};
+/** The field that makes a doc THIS run's. It is the phase-8 gate's entire discriminator. */
+const MEMORY_PROVENANCE_FIELD = "Source-Runs";
 const PHASE8_MEMORY_WRITE_RULE = {
 	artifact: PHASE8_MEMORY_ARTIFACT,
-	plane: ".recursive/memory/",
-	section: "Affected Memory Docs",
-	provenanceField: "Source-Runs",
+	plane: MEMORY_PLANE_PREFIX,
+	section: PHASE8_MEMORY_SECTION,
+	provenanceField: MEMORY_PROVENANCE_FIELD,
 	alwaysAvailable: ".recursive/memory/episodes/<run-id>.md",
-	kinds: Object.keys({
-		domain: {
-			dir: ".recursive/memory/domains",
-			type: "domain"
-		},
-		pattern: {
-			dir: ".recursive/memory/patterns",
-			type: "pattern"
-		},
-		incident: {
-			dir: ".recursive/memory/incidents",
-			type: "incident"
-		},
-		episode: {
-			dir: ".recursive/memory/episodes",
-			type: "episode"
-		},
-		skill: {
-			dir: ".recursive/memory/skills/patterns",
-			type: "pattern"
-		}
-	}),
+	kinds: Object.keys(MEMORY_DOC_LOCATIONS),
 	summary: "HARD: this run must have WRITTEN at least one doc under .recursive/memory/ before 08-memory-impact.md locks — .recursive/memory/episodes/<run-id>.md is always available — declared by path under `## Affected Memory Docs` and carrying `Source-Runs: <this-run-id>`; citing a shard this run did not write does not count.",
 	instruction: "HARD REQUIREMENT, CHECKED AT LOCK: before 08-memory-impact.md locks, this run must have WRITTEN at least one doc under .recursive/memory/ and declared that path under `## Affected Memory Docs`. A declared path counts ONLY when the doc on disk carries `Source-Runs` naming THIS run, because that is what separates \"the run wrote its memory\" from \"the run cited someone else's\". Render the doc with the metadata the memory-plane lint requires (Type, Status, Scope, Owns-Paths, Watch-Paths, Source-Runs, Validated-At-Commit, Last-Validated, Tags): .recursive/memory/episodes/<run-id>.md is always available for a run-local lesson, `.recursive/memory/domains/`, `.recursive/memory/patterns/` and `.recursive/memory/incidents/` hold generalized knowledge, and `.recursive/memory/skills/patterns/` is where a promoted skill lesson belongs. A doc missing a required field, or carrying a Type/Status the plane lint rejects, FAILS the memory plane — write it in the canonical shape. The written path enters the run diff under .recursive/memory/, which phase 8 OWNS in its Worktree Diff Audit and Requirement Completion Status."
 };
@@ -7173,6 +7194,149 @@ function renderMemoryMetadata(input) {
 	if (input.parent !== void 0 && input.parent.trim() !== "") lines.push("Parent: `" + input.parent.replace(/`/g, "'") + "`");
 	return lines.join("\n") + "\n";
 }
+function unquoteMemoryValue(value) {
+	const trimmed = value.trim();
+	for (const quote of [
+		"`",
+		"\"",
+		"'"
+	]) if (trimmed.length >= 2 && trimmed.startsWith(quote) && trimmed.endsWith(quote)) return trimmed.slice(1, -1).trim();
+	return trimmed;
+}
+/**
+* The values of a list field (`Source-Runs:`), inline or as bullets.
+*
+* ⚠ THE BLOCK ENDS AT THE FIRST BLANK LINE, HEADING OR NEW FIELD, and that strictness is the point:
+* the alternative is a parser that reads an unrelated bullet list further down the document as
+* provenance — and provenance is the one thing here that must never be guessed.
+*/
+function parseMemoryListField(content, fieldName) {
+	const fieldRe = new RegExp("^[ \\t]*(?:[-*][ \\t]+)?" + fieldName + ":[ \\t]*(.*)$");
+	const values = [];
+	let inField = false;
+	for (const line of content.replace(/\r\n/g, "\n").split("\n")) {
+		const field = fieldRe.exec(line);
+		if (field !== null) {
+			inField = true;
+			const inline = unquoteMemoryValue(field[1]);
+			if (inline !== "") values.push(inline);
+			continue;
+		}
+		if (!inField) continue;
+		const item = /^[ \t]*[-*][ \t]+(.+)$/.exec(line);
+		if (item !== null) {
+			const value = unquoteMemoryValue(item[1]);
+			if (value !== "") values.push(value);
+			continue;
+		}
+		break;
+	}
+	return values;
+}
+/** The runs a doc's `Source-Runs` names. EXACT matches: `run-1` is not `run-10`. */
+function memoryDocProvenance(content) {
+	return parseMemoryListField(content, MEMORY_PROVENANCE_FIELD);
+}
+function readTextOrNull(path) {
+	try {
+		return readFileSync(path, "utf8");
+	} catch {
+		return null;
+	}
+}
+/** Every `.recursive/memory/**` path a text declares, in the absolute or repo-relative spelling. */
+function phase8MemoryRefs(text) {
+	const found = /* @__PURE__ */ new Set();
+	const absolute = /(?:^|[\s(`'"<[])\/?\.recursive\/memory\/[A-Za-z0-9._@\-/]*\.md/g;
+	const relative = /(?:^|[\s(`'"<[])(memory\/(?:domains|patterns|incidents|episodes|training|skills|archive)\/[A-Za-z0-9._@\-/]*\.md)/g;
+	let match;
+	while ((match = absolute.exec(text)) !== null) found.add(match[0].replace(/^[\s(`'"<[]/, "").replace(/^\/+/, ""));
+	while ((match = relative.exec(text)) !== null) found.add(MEMORY_PLANE_PREFIX + match[1].slice(7));
+	return [...found].sort();
+}
+/**
+* T40 — THE CHECKABLE FACT BEHIND "the run wrote its durable memory".
+*
+* Three conditions, and each one exists because of a way the claim could be made without the work
+* being done: the artifact DECLARES a path under the plane (not prose about memory in general); the
+* path EXISTS (a declaration is not a write); and the doc on disk carries `Source-Runs` naming THIS
+* run (a shard the run merely read, or one an earlier run wrote, is not this run's memory).
+*
+* ⚠ WHAT IT CANNOT TELL, stated rather than hidden: WHEN the doc was written. A run that wrote a
+* memory doc before phase 8 and cites it here passes — and the phase 6/7 baselines deny memory-plane
+* writes outright (`phaseBaselineRules`), so within this workflow the only phase that can produce
+* such a doc is 8. The check is about the FACT existing at lock time, not about the clock.
+*/
+function phase8MemoryEvidence(root, runId, artifactText, readText = readTextOrNull) {
+	const declared = phase8MemoryRefs(artifactText);
+	if (declared.length === 0) return {
+		ok: false,
+		declared,
+		existing: [],
+		written: [],
+		reason: "the artifact declares no path under .recursive/memory/ at all"
+	};
+	const existing = [];
+	const written = [];
+	for (const path of declared) {
+		const text = readText(join(root, path));
+		if (text === null) continue;
+		existing.push(path);
+		if (memoryDocProvenance(text).includes(runId)) written.push(path);
+	}
+	if (written.length > 0) return {
+		ok: true,
+		declared,
+		existing,
+		written,
+		reason: written.length + " declared memory doc(s) carry Source-Runs naming " + runId + ": " + written.join(", ")
+	};
+	if (existing.length === 0) return {
+		ok: false,
+		declared,
+		existing,
+		written,
+		reason: "the artifact declares " + declared.length + " path(s) under .recursive/memory/ (" + declared.join(", ") + "), but none of them exists, so no memory doc was written"
+	};
+	return {
+		ok: false,
+		declared,
+		existing,
+		written,
+		reason: "the artifact declares " + existing.length + " existing memory doc(s) (" + existing.join(", ") + "), but none carries Source-Runs naming run " + runId + " — citing a shard this run did not write is not a write"
+	};
+}
+/**
+* T40 — THE REFUSAL, as a sentence, or null when the run may lock.
+*
+* ⚠ THE MESSAGE NAMES THE REMEDY, not only the fault. A refusal that says "no memory doc" leaves the
+* agent to guess a format it cannot guess (nine fields, five allowed Types, a provenance list), which
+* is how the step became a ticked box in the first place.
+*/
+function phase8MemoryRefusal(root, runId, artifactText, readText = readTextOrNull) {
+	const evidence = phase8MemoryEvidence(root, runId, artifactText, readText);
+	if (evidence.ok) return null;
+	return "locking 08-memory-impact.md requires this run to have WRITTEN a doc under .recursive/memory/: " + evidence.reason + ". Write one (memory/episodes/" + runId + ".md is always available), declare its path under `## Affected Memory Docs`, and give the doc `Source-Runs: " + runId + "` — then retry the lock.";
+}
+/**
+* T40 — THE LOCK-TIME ENTRY POINT: the refusal for the artifact being locked, or null.
+*
+* ⚠ THIS EXISTS SO THE GATE IS ONE LINE AT ITS CALL SITE. The decision (declared → exists → carries
+* this run's provenance) belongs in this module with the write surface that produces it; `lockArtifact`
+* should have to say only WHICH artifact it is locking, not how a memory doc is recognised. A caller
+* that has to reproduce the rule would be a second copy of it.
+*
+* ⚠ AND A MISSING ARTIFACT IS NOT THIS GATE'S REFUSAL. `lockArtifact` already refuses an absent
+* artifact before any gate can run, and returning a memory refusal for a file that does not exist
+* would replace "the artifact is missing" with a sentence about memory — a misleading diagnosis in
+* exchange for nothing.
+*/
+function phase8MemoryLockRefusal(root, runId, artifact) {
+	if (artifact !== PHASE8_ARTIFACT) return null;
+	const artifactText = readTextOrNull(join(root, ".recursive", "run", runId, PHASE8_ARTIFACT));
+	if (artifactText === null) return null;
+	return phase8MemoryRefusal(root, runId, artifactText);
+}
 //#endregion
 //#region src/run-spec.ts
 /** The named evidence classes, so a reader can tell a placeholder from an unmet gate. */
@@ -11804,6 +11968,16 @@ var RecursiveRuntime = class extends Service {
 		}
 		const inFlight = pendingWork(runDir);
 		if (inFlight.length > 0) throw new Error(toolError("PENDING_WORK", inFlight.map((p) => p.detail).join("; ")));
+		const memoryRefusal = phase8MemoryLockRefusal(root, runId, artifact);
+		if (memoryRefusal !== null) {
+			try {
+				this.blockRunToGoal(agent, runId, {
+					code: "phase8-memory-missing",
+					message: memoryRefusal
+				});
+			} catch {}
+			throw new Error(memoryRefusal);
+		}
 		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");

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@try-works/dsh-recursive-mode",
   "description": "recursive-mode workflow as a DeepSeek Harness bundle: RecursiveRuntime service + 13 recursive_* tools (recursive_status, recursive_init, recursive_lock, recursive_lint, recursive_closeout, recursive_scratch, recursive_worktree, recursive_phase, recursive_audit_team, recursive_review, recursive_delegate, recursive_ask, recursive_preview)",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",