@pmelab/gtd 51.0.0 → 51.0.1

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "gtd",
-  "version": "51.0.0",
+  "version": "51.0.1",
   "description": "Drive the gtd loop inside Claude Code: agent turns run as subagents, gtd decides every beat",
   "author": {
     "name": "Philipp Melab"

package/dist/gtd.bundle.mjs

@@ -38078,6 +38078,28 @@ const memoryScopeOf = (name) => {
 	const dot = name.lastIndexOf(".");
 	return dot === -1 ? "" : name.slice(0, dot);
 };
+/** Is `name` inside `scope`'s subtree? The root scope `""` holds everything. */
+const inScope = (name, scope) => scope === "" || name === scope || name.startsWith(`${scope}.`);
+/**
+* Where the current unbroken run of rests inside `scope`'s subtree began —
+* a dip into a descendant scope does not break it, a sibling or ancestor
+* does, and so does a fresh `scope()` call of the same scope.
+*/
+const scopeRunStart = (trace, scope) => {
+	let start = -1;
+	for (let k = 0; k < trace.length; k++) {
+		if (!inScope(trace[k].memoryScope, scope)) continue;
+		const previous = trace[k - 1];
+		if (!(previous !== void 0 && inScope(previous.memoryScope, scope) && scopeCallOf(previous, scope) === scopeCallOf(trace[k], scope))) start = k;
+	}
+	return start;
+};
+/** The innermost `scope()` call enclosing `scope` at `step` — a new call is a new conversation. */
+const scopeCallOf = (step, scope) => {
+	let call;
+	for (const entry of step.scopeCalls) if (inScope(scope, entry.prefix)) call = entry.call;
+	return call;
+};
 var Stop = class extends Error {};
 const short = (hash) => hash.slice(0, 7);
 /** One step's changes; content is read only when a flow asks for it. */
@@ -38337,12 +38359,13 @@ const replay = async (input) => {
 			skills: step.skills,
 			access: unfoldedAccess.get(step)
 		};
-		const seen = personas.get(step.memoryScope);
+		const conversation = `${step.memoryScope}#${scopeRunStart(trace, step.memoryScope)}`;
+		const seen = personas.get(conversation);
 		if (seen === void 0) {
-			personas.set(step.memoryScope, identity);
+			personas.set(conversation, identity);
 			return;
 		}
-		return samePersona(seen, identity) ? void 0 : `gtd: "${step.name}" runs with a different model, system prompt, skills or file access than an earlier agent step in memory scope "${step.memoryScope || "root"}" — one scope is one conversation, and a conversation has one identity`;
+		return samePersona(seen, identity) ? void 0 : `gtd: "${step.name}" runs with a different model, system prompt, skills or file access than an earlier agent step in its conversation in memory scope "${step.memoryScope || "root"}" — a conversation has one identity`;
 	};
 	const DIVERGED = "the workflow changed under this process; run `gtd abandon` to start over";
 	const blockerAt = (step) => {
@@ -40110,28 +40133,6 @@ const stepDefOf = (step) => {
 		case "human": return messageDef(common, request, step);
 	}
 };
-/** Is `name` inside `scope`'s subtree? The root scope `""` holds everything. */
-const inScope = (name, scope) => scope === "" || name === scope || name.startsWith(`${scope}.`);
-/**
-* Where the current unbroken run of rests inside `scope`'s subtree began —
-* a dip into a descendant scope does not break it, a sibling or ancestor
-* does, and so does a fresh `scope()` call of the same scope.
-*/
-const scopeRunStart = (trace, scope) => {
-	let start = -1;
-	for (let k = 0; k < trace.length; k++) {
-		if (!inScope(trace[k].memoryScope, scope)) continue;
-		const previous = trace[k - 1];
-		if (!(previous !== void 0 && inScope(previous.memoryScope, scope) && scopeCallOf(previous, scope) === scopeCallOf(trace[k], scope))) start = k;
-	}
-	return start;
-};
-/** The innermost `scope()` call enclosing `scope` at `step` — a new call is a new conversation. */
-const scopeCallOf = (step, scope) => {
-	let call;
-	for (const entry of step.scopeCalls) if (inScope(scope, entry.prefix)) call = entry.call;
-	return call;
-};
 const ROOT_MEMORY_SCOPE_NAME = "root";
 /**
 * An agent rest's memory key, `<scope>#<hash7>`: the hash is the commit the

package/dist/testkit.mjs

@@ -7124,6 +7124,28 @@ const memoryScopeOf = (name) => {
 	const dot = name.lastIndexOf(".");
 	return dot === -1 ? "" : name.slice(0, dot);
 };
+/** Is `name` inside `scope`'s subtree? The root scope `""` holds everything. */
+const inScope = (name, scope) => scope === "" || name === scope || name.startsWith(`${scope}.`);
+/**
+* Where the current unbroken run of rests inside `scope`'s subtree began —
+* a dip into a descendant scope does not break it, a sibling or ancestor
+* does, and so does a fresh `scope()` call of the same scope.
+*/
+const scopeRunStart = (trace, scope) => {
+	let start = -1;
+	for (let k = 0; k < trace.length; k++) {
+		if (!inScope(trace[k].memoryScope, scope)) continue;
+		const previous = trace[k - 1];
+		if (!(previous !== void 0 && inScope(previous.memoryScope, scope) && scopeCallOf(previous, scope) === scopeCallOf(trace[k], scope))) start = k;
+	}
+	return start;
+};
+/** The innermost `scope()` call enclosing `scope` at `step` — a new call is a new conversation. */
+const scopeCallOf = (step, scope) => {
+	let call;
+	for (const entry of step.scopeCalls) if (inScope(scope, entry.prefix)) call = entry.call;
+	return call;
+};
 var Stop = class extends Error {};
 const short = (hash) => hash.slice(0, 7);
 /** One step's changes; content is read only when a flow asks for it. */
@@ -7383,12 +7405,13 @@ const replay = async (input) => {
 			skills: step.skills,
 			access: unfoldedAccess.get(step)
 		};
-		const seen = personas.get(step.memoryScope);
+		const conversation = `${step.memoryScope}#${scopeRunStart(trace, step.memoryScope)}`;
+		const seen = personas.get(conversation);
 		if (seen === void 0) {
-			personas.set(step.memoryScope, identity);
+			personas.set(conversation, identity);
 			return;
 		}
-		return samePersona(seen, identity) ? void 0 : `gtd: "${step.name}" runs with a different model, system prompt, skills or file access than an earlier agent step in memory scope "${step.memoryScope || "root"}" — one scope is one conversation, and a conversation has one identity`;
+		return samePersona(seen, identity) ? void 0 : `gtd: "${step.name}" runs with a different model, system prompt, skills or file access than an earlier agent step in its conversation in memory scope "${step.memoryScope || "root"}" — a conversation has one identity`;
 	};
 	const DIVERGED = "the workflow changed under this process; run `gtd abandon` to start over";
 	const blockerAt = (step) => {
@@ -9145,28 +9168,6 @@ const stepDefOf = (step) => {
 		case "human": return messageDef(common, request, step);
 	}
 };
-/** Is `name` inside `scope`'s subtree? The root scope `""` holds everything. */
-const inScope = (name, scope) => scope === "" || name === scope || name.startsWith(`${scope}.`);
-/**
-* Where the current unbroken run of rests inside `scope`'s subtree began —
-* a dip into a descendant scope does not break it, a sibling or ancestor
-* does, and so does a fresh `scope()` call of the same scope.
-*/
-const scopeRunStart = (trace, scope) => {
-	let start = -1;
-	for (let k = 0; k < trace.length; k++) {
-		if (!inScope(trace[k].memoryScope, scope)) continue;
-		const previous = trace[k - 1];
-		if (!(previous !== void 0 && inScope(previous.memoryScope, scope) && scopeCallOf(previous, scope) === scopeCallOf(trace[k], scope))) start = k;
-	}
-	return start;
-};
-/** The innermost `scope()` call enclosing `scope` at `step` — a new call is a new conversation. */
-const scopeCallOf = (step, scope) => {
-	let call;
-	for (const entry of step.scopeCalls) if (inScope(scope, entry.prefix)) call = entry.call;
-	return call;
-};
 const ROOT_MEMORY_SCOPE_NAME = "root";
 /**
 * An agent rest's memory key, `<scope>#<hash7>`: the hash is the commit the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmelab/gtd",
-  "version": "51.0.0",
+  "version": "51.0.1",
   "private": false,
   "description": "Git-aware CLI that emits the next prompt for an autonomous coding agent based on the current repository state",
   "bin": {

package/src/edge/Edge.ts

@@ -37,6 +37,7 @@ import {
   isRecordableApproval,
   parseCommitMessage,
   replay,
+  scopeRunStart,
   sliceRanges,
   treeFromRecord,
   type EpisodeCommit,
@@ -791,36 +792,6 @@ const stepDefOf = (step: ReachedStep): StepDef => {
   }
 }
 
-/** Is `name` inside `scope`'s subtree? The root scope `""` holds everything. */
-const inScope = (name: string, scope: string): boolean =>
-  scope === "" || name === scope || name.startsWith(`${scope}.`)
-
-/**
- * Where the current unbroken run of rests inside `scope`'s subtree began —
- * a dip into a descendant scope does not break it, a sibling or ancestor
- * does, and so does a fresh `scope()` call of the same scope.
- */
-const scopeRunStart = (trace: readonly ReachedStep[], scope: string): number => {
-  let start = -1
-  for (let k = 0; k < trace.length; k++) {
-    if (!inScope(trace[k]!.memoryScope, scope)) continue
-    const previous = trace[k - 1]
-    const unbroken =
-      previous !== undefined &&
-      inScope(previous.memoryScope, scope) &&
-      scopeCallOf(previous, scope) === scopeCallOf(trace[k]!, scope)
-    if (!unbroken) start = k
-  }
-  return start
-}
-
-/** The innermost `scope()` call enclosing `scope` at `step` — a new call is a new conversation. */
-const scopeCallOf = (step: ReachedStep, scope: string): number | undefined => {
-  let call: number | undefined
-  for (const entry of step.scopeCalls) if (inScope(scope, entry.prefix)) call = entry.call
-  return call
-}
-
 // Shown for the root scope, which has no name of its own.
 const ROOT_MEMORY_SCOPE_NAME = "root"
 

package/src/replay/Replay.test.ts

@@ -940,7 +940,7 @@ describe("replay: skills resolution", () => {
     expect(await wireSkills(inScope({ name: "a" }, step), { skills: { a: [] } })).toBeUndefined()
   })
 
-  it("fails two agent steps in one memory scope with different lists", async () => {
+  it("runs two scope() calls of one memory scope with different lists as two conversations", async () => {
     const flow: Flow = async () => {
       await scope({ name: "a", skills: ["one"] }, async () => {
         await agent("first", "prompt")
@@ -959,9 +959,7 @@ describe("replay: skills resolution", () => {
       start: hashOf(0),
       budgetBytes: 1024,
     })
-    expect(outcome.kind === "failed" && outcome.message).toContain(
-      "different model, system prompt, skills or file access",
-    )
+    expect(outcome.kind).toBe("rest")
   })
 })
 
@@ -1084,7 +1082,7 @@ describe("replay: access resolution", () => {
     expect(outcome.rest.access).toEqual({ read: null, write: ["src/a.ts"] })
   })
 
-  it("fails two agent steps in one memory scope with different scope access", async () => {
+  it("runs two scope() calls of one memory scope with different access as two conversations", async () => {
     const flow: Flow = async () => {
       await scope({ name: "a", access: { write: ["one"] } }, () => agent("first", "prompt"))
       await scope({ name: "a", access: { write: ["two"] } }, () => agent("second", "prompt"))
@@ -1092,9 +1090,7 @@ describe("replay: access resolution", () => {
     const history = new History()
     history.land("agent", "a.first", 1, "a.second", { "x.txt": "x" })
     const outcome = await restOf(flow, {}, history)
-    expect(outcome.kind === "failed" && outcome.message).toContain(
-      "different model, system prompt, skills or file access",
-    )
+    expect(outcome.kind).toBe("rest")
   })
 
   it("does not conflict two steps that differ only in steering file", async () => {

package/src/replay/Replay.ts

@@ -139,6 +139,36 @@ const memoryScopeOf = (name: string): string => {
   return dot === -1 ? "" : name.slice(0, dot)
 }
 
+/** Is `name` inside `scope`'s subtree? The root scope `""` holds everything. */
+const inScope = (name: string, scope: string): boolean =>
+  scope === "" || name === scope || name.startsWith(`${scope}.`)
+
+/**
+ * Where the current unbroken run of rests inside `scope`'s subtree began —
+ * a dip into a descendant scope does not break it, a sibling or ancestor
+ * does, and so does a fresh `scope()` call of the same scope.
+ */
+export const scopeRunStart = (trace: readonly ReachedStep[], scope: string): number => {
+  let start = -1
+  for (let k = 0; k < trace.length; k++) {
+    if (!inScope(trace[k]!.memoryScope, scope)) continue
+    const previous = trace[k - 1]
+    const unbroken =
+      previous !== undefined &&
+      inScope(previous.memoryScope, scope) &&
+      scopeCallOf(previous, scope) === scopeCallOf(trace[k]!, scope)
+    if (!unbroken) start = k
+  }
+  return start
+}
+
+/** The innermost `scope()` call enclosing `scope` at `step` — a new call is a new conversation. */
+const scopeCallOf = (step: ReachedStep, scope: string): number | undefined => {
+  let call: number | undefined
+  for (const entry of step.scopeCalls) if (inScope(scope, entry.prefix)) call = entry.call
+  return call
+}
+
 class Stop extends Error {}
 
 const short = (hash: string): string => hash.slice(0, 7)
@@ -505,14 +535,16 @@ export const replay = async (input: ReplayInput): Promise<ReplayOutcome> => {
       skills: step.skills,
       access: unfoldedAccess.get(step),
     }
-    const seen = personas.get(step.memoryScope)
+    // Keyed like the memory key: a fresh scope() call is a fresh conversation, free to differ.
+    const conversation = `${step.memoryScope}#${scopeRunStart(trace, step.memoryScope)}`
+    const seen = personas.get(conversation)
     if (seen === undefined) {
-      personas.set(step.memoryScope, identity)
+      personas.set(conversation, identity)
       return undefined
     }
     return samePersona(seen, identity)
       ? undefined
-      : `gtd: "${step.name}" runs with a different model, system prompt, skills or file access than an earlier agent step in memory scope "${step.memoryScope || "root"}" — one scope is one conversation, and a conversation has one identity`
+      : `gtd: "${step.name}" runs with a different model, system prompt, skills or file access than an earlier agent step in its conversation in memory scope "${step.memoryScope || "root"}" — a conversation has one identity`
   }
 
   const DIVERGED = "the workflow changed under this process; run `gtd abandon` to start over"

package/src/replay/index.ts

@@ -1,4 +1,10 @@
-export { replay, type EpisodeCommit, type ReachedStep, type ReplayOutcome } from "./Replay.js"
+export {
+  replay,
+  scopeRunStart,
+  type EpisodeCommit,
+  type ReachedStep,
+  type ReplayOutcome,
+} from "./Replay.js"
 export { treeFromRecord, type TreeView } from "./Tree.js"
 export {
   formatCommitMessage,