@visual-z/xeno 0.7.1 → 0.8.0

package/src/runtime/foundation.ts

@@ -12,15 +12,27 @@ import { LspManager, parseLspConfig } from "./lsp-client.ts";
 import { validateFormatters } from "./formatter.ts";
 import { createFormatterTool } from "./formatter-tool.ts";
 import { permissionResourceAction } from "./permission-resources.ts";
-import type { ToolContext, ToolDefinition, ToolResult } from "./tools.ts";
+import type { InstructionCheck, ToolContext, ToolDefinition } from "./tools.ts";
 import { McpManager } from "./mcp-client.ts";
 import { parseMcpServers } from "../core/mcp-config.ts";
 import type { ExtensionRegistry } from "./extensions.ts";
 import { join } from "node:path";
 import { getBlob } from "../store/blobs.ts";
 
+/**
+ * Calls that only observe run and carry newly discovered rules (S.6 item 3:
+ * OpenCode, Gemini CLI and Claude Code do the same). A change is still held
+ * back until the rules have been read: the reason for blocking first was never
+ * to notify after a modification (foundation-editing research).
+ */
+const OBSERVING_TOOLS = new Set(["read", "query", "lsp"]);
+/** Assumed: more batches than any interleaving of live sessions sharing this runtime. */
+const RECENT_BATCHES = 16;
+
 export class FoundationRuntime {
   readonly questionSlot: QuestionSlot;
+  /** Per batch (assistant event id): instruction key -> the call that carried it. */
+  private readonly batches = new Map<string, Map<string, string>>();
   readonly mcp: McpManager;
   readonly tools: ToolDefinition[];
   readonly permissions: PermissionRule[];
@@ -47,14 +59,32 @@ export class FoundationRuntime {
     const discovered = await this.mcp.discover();
     for (const integration of discovered.integrations) registry.api("xeno-mcp").registerIntegration(integration);
   }
-  async instructions(ctx: ToolContext, name: string, input: unknown, noContextFiles: boolean): Promise<ToolResult | null> {
+  /** Calls are prepared one at a time in their batch, so "first to discover carries the rules" is deterministic. */
+  private claims(batch: string): Map<string, string> {
+    let claimed = this.batches.get(batch);
+    if (claimed === undefined) {
+      claimed = new Map();
+      this.batches.set(batch, claimed);
+      for (const old of this.batches.keys()) if (this.batches.size > RECENT_BATCHES) this.batches.delete(old);
+    }
+    return claimed;
+  }
+  async instructions(ctx: ToolContext, name: string, input: unknown, noContextFiles: boolean): Promise<InstructionCheck | null> {
     if (noContextFiles || !["read", "write", "edit", "apply_patch", "query", "format", "lsp"].includes(name) || !input || typeof input !== "object") return null;
     const args = input as Record<string, unknown>;
     const paths = name === "apply_patch" ? patchPaths(parsePatch(String(args["patchText"]))) : typeof args["path"] === "string" ? [args["path"]] : Array.isArray(args["paths"]) ? args["paths"].filter((path): path is string => typeof path === "string") : [];
     if (!paths.length) return null;
+    const blocked = (content: string): InstructionCheck => ({ kind: "block", result: { ok: false, content } });
     const known = new Set<string>();
-    for (const event of await ctx.historyEvents?.() ?? []) {
-      if (event.t !== "tool_result") continue;
+    const history = await ctx.historyEvents?.() ?? [];
+    // Rules count as read only once the model has seen them: results of this
+    // same batch may already be committed, but they reach the model together
+    // with this call's result. Within the batch, claims decide instead.
+    const batch = history.findLast(event => event.t === "assistant");
+    const sameBatch = new Set(batch?.t === "assistant" ? batch.blocks.flatMap(block => block.type === "tool_use" ? [block.call_id] : []) : []);
+    for (const event of history) {
+      if (event.t !== "tool_result" || sameBatch.has(event.call_id)) continue;
+      for (const key of event.instructions?.keys ?? []) known.add(key);
       let data: unknown = event.data;
       if (event.data_ref && ctx.outputStore) {
         const saved = await getBlob(ctx.outputStore, event.data_ref.sha256);
@@ -67,12 +97,20 @@ export class FoundationRuntime {
     }
     const found = await discoverTargetInstructions({ workspace: ctx.root, paths, known,
       canRead: async path => await permissionResourceAction(ctx.root, path, ctx.rules ?? [], ctx.sessionRules ?? []) === "allow" });
-    if (found.notices.some(notice => notice.kind === "skipped" && notice.reason === "instruction read permission is unavailable")) return { ok: false, content: "Scoped instructions require read permission before this operation." };
+    if (found.notices.some(notice => notice.kind === "skipped" && notice.reason === "instruction read permission is unavailable")) return blocked("Scoped instructions require read permission before this operation.");
     const files = found.files.filter(file => !ctx.frozenSystem?.().includes(file.content));
     if (!files.length) return null;
-    for (const file of files) if (await permissionResourceAction(ctx.root, file.path, ctx.rules ?? [], ctx.sessionRules ?? []) !== "allow") return { ok: false, content: "Scoped instructions require read permission before this operation." };
-    return { ok: false, content: "Scoped instructions were discovered. Read and follow them before deciding whether to retry the original operation. No original operation was executed.\n\n" + renderTargetInstructions(files),
-      data: { kind: "scoped_instructions", keys: files.map(file => file.key), files: files.map(file => ({ path: file.path, scope: file.scope, key: file.key, content: file.content, truncated: file.truncated })) } };
+    for (const file of files) if (await permissionResourceAction(ctx.root, file.path, ctx.rules ?? [], ctx.sessionRules ?? []) !== "allow") return blocked("Scoped instructions require read permission before this operation.");
+    // Once per batch: a later call in the same assistant message does not receive the same rules again.
+    const claimed = this.claims(batch?.id ?? "");
+    const fresh = files.filter(file => !claimed.has(file.key));
+    const carriers = [...new Set(files.flatMap(file => claimed.get(file.key) ?? []))];
+    for (const file of fresh) claimed.set(file.key, ctx.callId ?? name);
+    if (OBSERVING_TOOLS.has(name)) return fresh.length ? { kind: "attach", instructions: { keys: fresh.map(file => file.key), text: renderTargetInstructions(fresh) } } : null;
+    const earlier = carriers.length ? `Scoped instructions for this target were attached to the result of ${carriers.join(", ")} in this batch. ` : "";
+    if (!fresh.length) return blocked(`${earlier}No original operation was executed. Follow them, then retry.`);
+    return { kind: "block", result: { ok: false, content: `Scoped instructions were discovered. ${earlier}Read and follow them before deciding whether to retry the original operation. No original operation was executed.\n\n` + renderTargetInstructions(fresh),
+      data: { kind: "scoped_instructions", keys: fresh.map(file => file.key), files: fresh.map(file => ({ path: file.path, scope: file.scope, key: file.key, content: file.content, truncated: file.truncated })) } } };
   }
   async dispose(): Promise<void> { await Promise.all([this.lsp.dispose(), this.mcp.dispose()]); }
 }