@gonrocca/nodd 0.2.0 → 0.2.2

package/README.md

@@ -87,6 +87,30 @@ steps**: they run no model and cannot be assigned one. `/nodd-models` shows them
 as `mecanismo · sin modelo` and refuses an assignment. The other three are the
 steps where a model actually does work.
 
+## Choosing models
+
+`/nodd-models` with no argument opens a picker: profiles, then slots, then the
+providers and models of pi's live registry, then a thinking level. Nothing is
+written until `— guardar y salir —`; leaving with `q` writes nothing at all.
+
+A **profile** is a named set of assignments — `rapido`, `barato`, whatever you
+call it — and the picker can create, edit, duplicate, activate and delete them.
+The active profile is what the generated agents read. Editing a slot while a
+profile is active edits that profile, so the two never drift apart silently.
+
+The slot and the level both reach the generated agent's frontmatter as `model:`
+and `thinking:`. **Changes apply to the next pi session**, not the running one:
+the agent files are rewritten from the config when the extension loads, which
+happens at startup.
+
+The text forms do the same without the UI:
+
+```bash
+/nodd-models implement=anthropic/claude-opus-4-1
+/nodd-models profile new rapido
+/nodd-models profile use rapido
+```
+
 ## The gates
 
 | gate | fires on | refuses when |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gonrocca/nodd",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Non-negotiable Organic Driven Development — the ODD protocol as runtime mechanism for pi: blocking gates, observed evidence, and promotion to /forge.",
   "type": "module",
   "keywords": [

package/src/gates/request.ts

@@ -11,7 +11,10 @@ export type GateRequest = {
 };
 
 export function targetPath(request: GateRequest): string | null {
-  const path = request.input?.path;
+  // pi's own write and edit tools accept either name and read `file_path ??
+  // path` (`write.js:99`, `edit.js:92`), and the write tool sends `file_path`.
+  // Reading only `path` left every path-scoped rule blind on the real tool.
+  const path = request.input?.file_path ?? request.input?.path;
   return typeof path === "string" && path !== "" ? path : null;
 }
 

package/src/gates/track.test.ts

@@ -47,6 +47,20 @@ test("mutating bash blocks while a test command does not", () => {
 
 // A doc the model can rewrite is a doc the model can forge, and then evidence
 // is prose again. This holds even when the doc exists and the route is inline.
+test("file_path is read like path: pi's write tool sends either", () => {
+  // `write.js:99` and `edit.js:92` both accept `file_path ?? path`, and pi's
+  // own write tool sends `file_path`. Reading only `path` left every
+  // path-scoped rule blind on the real tool: the .nodd/ guard below let a
+  // direct write to the feature document through.
+  const decision = trackGate(
+    routed("tracked"),
+    { toolName: "write", input: { file_path: "/repo/.nodd/demo/feature.md" } },
+    emptyPolicy(),
+    present,
+  );
+  assert.equal(decision.allow, false, "a write under .nodd/ is refused however pi names the argument");
+});
+
 test("a direct write to .nodd/** is always blocked, pointing at nodd_task", () => {
   for (const state of [routed("tracked"), routed("inline"), emptyCommitted()]) {
     for (const path of [".nodd/x/feature.md", ".nodd/demo/state.json", "/repo/.nodd/demo/feature.md"]) {

package/src/state.test.ts

@@ -53,6 +53,20 @@ test("a fixed sequence folds into an exact snapshot", () => {
   });
 });
 
+test("a write naming file_path is recorded, like pi's own write tool sends it", () => {
+  // pi's write tool sends `file_path` (`write.js:99`); edit accepts both
+  // (`edit.js:92`). Reading only `path` left filesWritten empty on every real
+  // write — and filesWritten is what evidence times a checkoff against and what
+  // delegate counts, so both went blind against the actual tool.
+  const committed = foldAll(emptyCommitted(), [
+    obs({ toolName: "write", input: { file_path: "c.ts" } }),
+    obs({ toolName: "read", input: { file_path: "a.ts" } }),
+  ]);
+
+  assert.deepEqual([...committed.filesWritten.keys()], ["c.ts"]);
+  assert.deepEqual([...committed.filesRead], ["a.ts"]);
+});
+
 test("distinct-path counting: one file read six times is one file", () => {
   const events = Array.from({ length: 6 }, () => obs({ toolName: "read", input: { path: "same.ts" } }));
   const committed = foldAll(emptyCommitted(), events);

package/src/state.ts

@@ -117,7 +117,10 @@ export function fold(committed: Committed, obs: Observation): Committed {
     declaration: committed.declaration,
   };
 
-  const path = str(obs.input.path);
+  // `file_path ?? path`: pi's write tool sends the first, edit accepts both
+  // (`write.js:99`, `edit.js:92`). Reading only `path` left filesWritten empty
+  // on every real write, which is what evidence and delegate count.
+  const path = str(obs.input.file_path) || str(obs.input.path);
   if (READ_TOOLS.has(obs.toolName) && path) next.filesRead.add(path);
   if (WRITE_TOOLS.has(obs.toolName) && path) next.filesWritten.set(path, { at: obs.at, seq: next.toolCalls });