@yagni-app/code-staging 1.1.4-staging.1416.1 → 1.1.4-staging.1419.1

package/dist/extension/index.js

@@ -17,7 +17,7 @@ import { makeRecordDecisionTool } from "./recordDecisionTool.js";
 import { makeSuggestNextWorkTool } from "./nextWorkTool.js";
 import { BRAND_NAME, brandSystemPrompt, brandingDisabled, buildMastheadString, YAGNI_IDENTITY_DRIVER, YAGNI_IDENTITY_DRIVER_GROUNDING_FREE, YAGNI_IDENTITY_GROUNDING_FREE, YAGNI_IDENTITY_ULTRA, YAGNI_IDENTITY_ULTRA_GROUNDING_FREE } from "./branding.js";
 import { claudeRulesSection } from "./claudeRules.js";
-import { ensureScratchpadDir, SCRATCHPAD_TMPDIR_ENV, scratchpadDir as scratchpadDirFor, scratchpadSection } from "./scratchpad.js";
+import { ensureScratchpadDir, SCRATCHPAD_TMPDIR_ENV, scratchpadDir as scratchpadDirFor, scratchpadOwnerRootFor, scratchpadSection } from "./scratchpad.js";
 import { registerCostCommand } from "./costHud.js";
 import { isDebug } from "./diagnostics.js";
 import { logEvent } from "./errorSink.js";
@@ -1339,24 +1339,69 @@ export async function registerYagni(pi, deps = {}) {
     // so the very first turn already carries the section. Fails closed: no
     // sessionId (a bare pi run) or a failed mkdir means no section, and the mkdir
     // failure is logged so a missing scratchpad is not silent.
+    const scratchpadTmpRoot = env[SCRATCHPAD_TMPDIR_ENV] || undefined;
     const scratchpadDirPath = scratchpadDirFor({
         sessionId: env.YAGNI_SESSION_ID ?? undefined,
         cwd: process.cwd(),
-        tmp: env[SCRATCHPAD_TMPDIR_ENV] || undefined,
+        tmp: scratchpadTmpRoot,
     });
     let scratchpadSectionText;
     if (scratchpadDirPath) {
-        const ensured = ensureScratchpadDir(scratchpadDirPath);
+        const ensured = ensureScratchpadDir(scratchpadDirPath, undefined, {
+            onError: (errorCode) => {
+                logEvent({
+                    source: "scratchpad",
+                    level: "error",
+                    event: "scratchpad_mkdir_failed",
+                    sessionId: env.YAGNI_SESSION_ID ?? undefined,
+                    fields: { path: scratchpadDirPath, errorCode },
+                });
+            },
+        });
         if (ensured) {
             scratchpadSectionText = scratchpadSection(ensured);
-        }
-        else {
-            logEvent({
-                source: "scratchpad",
-                level: "error",
-                event: "scratchpad_mkdir_failed",
-                sessionId: env.YAGNI_SESSION_ID ?? undefined,
-            });
+            // Claude Code parity: srt reads CLAUDE_CODE_TMPDIR from THIS process's
+            // env when wrapping a sandboxed bash command and forces the child's
+            // TMPDIR onto it. Point it at the per-user scratchpad OWNER ROOT (not
+            // the scratchpad itself) so sandboxed-bash temp files land in the same
+            // per-user tree the scratchpad lives in, under a path SHORT enough for
+            // named unix-socket binds (the test-runner IPC pattern — a deep
+            // scratchpad TMPDIR trips macOS's 104-char sun_path limit with EINVAL).
+            // The scratchpad remains the sanctioned staging place by PRIORITY (the
+            // prompt section outranks $TMPDIR), not by path convergence.
+            //
+            // Production note: children (subagents, /go stages) inherit this env
+            // because `env` IS process.env there and the runner spawns with it. A
+            // harness injecting deps.env sees the write only in that object —
+            // spawned children of such a harness do not, by construction of the
+            // runner's own env seam.
+            //
+            // Unset when there is no scratchpad (no session id, or the mkdir
+            // failed) — srt keeps its /tmp/claude default and nothing changes for
+            // those sessions.
+            if (!env.CLAUDE_CODE_TMPDIR) {
+                const ownerRoot = scratchpadOwnerRootFor({ tmp: scratchpadTmpRoot });
+                env.CLAUDE_CODE_TMPDIR = ownerRoot;
+                logEvent({
+                    source: "scratchpad",
+                    level: "info",
+                    event: "scratchpad_tmpdir_pinned",
+                    sessionId: env.YAGNI_SESSION_ID ?? undefined,
+                    fields: { path: ownerRoot },
+                });
+            }
+            else {
+                // The trail must distinguish "pinned" from "respected an operator
+                // override" — no path value here (the explicit value is the
+                // operator's, not ours to echo).
+                logEvent({
+                    source: "scratchpad",
+                    level: "info",
+                    event: "scratchpad_tmpdir_pin_skipped",
+                    sessionId: env.YAGNI_SESSION_ID ?? undefined,
+                    fields: {},
+                });
+            }
         }
     }
     // The condensed Claude Code-style transcript: the seven built-ins re-render

package/dist/extension/sandbox/session.js

@@ -118,8 +118,10 @@ export function makeBashComposition(manager, settings, cwd, onShellResolutionRet
         const heredocNote = "Caveat: heredocs (<<EOF) write temp files relative to the current directory on macOS bash 3.2 — from an unwritable cwd they fail; prefer printf or redirect from a file in the working directory.";
         // $TMPDIR guidance (Claude Code parity, always-on): the sandbox sets
         // TMPDIR to the per-user sandbox-writable temp dir; /tmp itself is NOT
-        // writable.
-        const tmpdirNote = "For temporary files, always use the $TMPDIR environment variable. TMPDIR is automatically set to the correct sandbox-writable directory in sandbox mode. Do NOT use /tmp directly - use $TMPDIR instead.";
+        // writable. When the system prompt names a scratchpad directory, that
+        // directory takes priority for temporary files — stated here so the two
+        // guidance lines never read as mutually exclusive always-rules.
+        const tmpdirNote = "For temporary files, use the $TMPDIR environment variable unless your system prompt names a scratchpad directory — the scratchpad takes priority for temporary files. TMPDIR is automatically set to the correct sandbox-writable directory in sandbox mode. Do NOT use /tmp directly - use $TMPDIR instead.";
         const wrapped = {
             ...def,
             description: `${def.description}\n\n## Command sandbox\nCommands run inside an OS sandbox: ${restrictions.join("; ")}. ${strictNote}\n${heredocNote}\n${tmpdirNote}`,

package/dist/extension/scratchpad.d.ts

@@ -48,6 +48,18 @@ export declare function scratchpadDir(opts?: {
     uid?: number;
     tmp?: string;
 }): string | null;
+/**
+ * PURE: the per-user scratchpad OWNER ROOT, recomputed from the SAME inputs
+ * `scratchpadDir` resolves from (never derived by stripping segments off a
+ * built path — a layout change would silently shift a stripped spelling).
+ * The value the sandbox forces TMPDIR onto (Claude parity): per-user, shared
+ * across sessions, and short enough for named unix-socket binds where the
+ * deep scratchpad path would trip macOS's 104-char sun_path limit.
+ */
+export declare function scratchpadOwnerRootFor(opts?: {
+    uid?: number;
+    tmp?: string;
+}): string;
 /**
  * IMPURE: ensure the scratchpad dir exists (owner-only), failing soft. Returns
  * the path on success and null on failure — a null result means "no scratchpad
@@ -56,7 +68,9 @@ export declare function scratchpadDir(opts?: {
 export declare function ensureScratchpadDir(path: string, mkdir?: (p: string, o: {
     mode: number;
     recursive: boolean;
-}) => void): string | null;
+}) => void, opts?: {
+    onError?: (errorCode: string) => void;
+}): string | null;
 /**
  * PURE: the prompt section naming the scratchpad. Gated by the caller on the
  * dir existing; when present, it tells the agent where to put intermediate

package/dist/extension/scratchpad.js

@@ -61,17 +61,39 @@ export function scratchpadDir(opts = {}) {
     const cwd = sanitizeCwdSegment(opts.cwd ?? ".");
     return join(tmp, scratchpadOwnerDir(uid), cwd, sessionId, "scratchpad");
 }
+/**
+ * PURE: the per-user scratchpad OWNER ROOT, recomputed from the SAME inputs
+ * `scratchpadDir` resolves from (never derived by stripping segments off a
+ * built path — a layout change would silently shift a stripped spelling).
+ * The value the sandbox forces TMPDIR onto (Claude parity): per-user, shared
+ * across sessions, and short enough for named unix-socket binds where the
+ * deep scratchpad path would trip macOS's 104-char sun_path limit.
+ */
+export function scratchpadOwnerRootFor(opts = {}) {
+    const tmp = opts.tmp ?? tmpdir();
+    const uid = opts.uid ?? (typeof process.getuid === "function" ? process.getuid() ?? 0 : 0);
+    return join(tmp, scratchpadOwnerDir(uid));
+}
 /**
  * IMPURE: ensure the scratchpad dir exists (owner-only), failing soft. Returns
  * the path on success and null on failure — a null result means "no scratchpad
  * this session", which the caller turns into an omitted prompt section.
  */
-export function ensureScratchpadDir(path, mkdir = mkdirSync) {
+export function ensureScratchpadDir(path, mkdir = mkdirSync, opts = {}) {
     try {
         mkdir(path, { recursive: true, mode: 0o700 });
         return path;
     }
-    catch {
+    catch (err) {
+        // The errno CODE (never the thrown message — the message can carry a
+        // path or system detail, and the caller forwards this to the sink).
+        // fs errors are plain Error instances whose distinguishing value is
+        // .code (ENOTDIR vs EACCES vs EPERM...); the constructor name would
+        // always read "Error" and distinguish nothing. The fallback keeps the
+        // class name for codeless throws (a non-fs throw), so the callback's
+        // value is "errno code, or class name when there is no code".
+        const code = err?.code;
+        opts.onError?.(code ?? (err instanceof Error ? err.constructor.name : typeof err));
         return null;
     }
 }
@@ -82,12 +104,13 @@ export function ensureScratchpadDir(path, mkdir = mkdirSync) {
  */
 export function scratchpadSection(dir) {
     return ("# Scratchpad directory\n\n" +
-        `Use this session scratchpad directory for files that do not belong in the user's project:\n` +
+        `IMPORTANT: Always use this scratchpad directory for temporary files instead of /tmp or other system temp directories (including $TMPDIR in sandboxed bash):\n` +
         `${dir}\n\n` +
+        "Use this directory for ALL temporary file needs:\n" +
         "- Store intermediate results or data during multi-step tasks.\n" +
         "- Write temporary scripts or configuration files.\n" +
         "- Save outputs that don't belong in the user's project.\n" +
-        "- Anything that would otherwise go to /tmp.\n\n" +
+        "- Staging files for subagents: paths in this directory are readable by every subagent of this session, so hand subagents scratchpad paths rather than $TMPDIR or /tmp paths.\n\n" +
         "The directory is session-specific and isolated from the user's project.");
 }
 //# sourceMappingURL=scratchpad.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yagni-app/code-staging",
-  "version": "1.1.4-staging.1416.1",
+  "version": "1.1.4-staging.1419.1",
   "description": "YAGNI Code: a terminal coding agent that already knows your company. One YAGNI login routes the model and grounds the agent in your team's context.",
   "license": "SEE LICENSE IN LICENSE.md",
   "author": "YAGNI, Inc. <jack@yagni.app> (https://yagni.app)",
@@ -58,5 +58,5 @@
     "turndown": "^7.2.4",
     "typebox": "^1.3.15"
   },
-  "yagniSourceSha": "f17aa2f61573701f8a9b62da1d99ca022b96a7bd"
+  "yagniSourceSha": "72326f4909f8b24a2657ae8ddd9caa4f4ad2e614"
 }