instar 1.3.774 → 1.3.775

package/dist/core/PostUpdateMigrator.js

@@ -3627,6 +3627,13 @@ export class PostUpdateMigrator {
         catch (err) {
             result.errors.push(`pr-hand-lease-guard.js: ${err instanceof Error ? err.message : String(err)}`);
         }
+        try {
+            fs.writeFileSync(path.join(instarHooksDir, 'working-set-artifact-recorder.js'), this.getWorkingSetArtifactRecorderHook(), { mode: 0o755 });
+            result.upgraded.push('hooks/instar/working-set-artifact-recorder.js (interactive working-set artifact recorder, PostToolUse Write/Edit, fire-and-forget, dark by default)');
+        }
+        catch (err) {
+            result.errors.push(`working-set-artifact-recorder.js: ${err instanceof Error ? err.message : String(err)}`);
+        }
         try {
             fs.writeFileSync(path.join(instarHooksDir, 'doorway-scan-guard.js'), this.getDoorwayScanGuardHook(), { mode: 0o755 });
             result.upgraded.push('hooks/instar/doorway-scan-guard.js (doorway-scan command-allowlist guard, PreToolUse Bash, scope-fail-open/match-fail-closed)');
@@ -8286,6 +8293,32 @@ Two layers keep my machine-to-machine \"ropes\" (Tailscale / LAN / Cloudflare) h
         else {
             result.skipped.push('.claude/settings.json: PreToolUse MCP matcher already present');
         }
+        // Add PostToolUse Write/Edit matcher for the working-set artifact recorder
+        // (intelligent-working-set-lazy-sync F8). Fire-and-forget + non-blocking; the
+        // hook itself early-exits fast when the feature is off (dark by default:
+        // coherenceJournal.workingSet.recordInteractive), so a default install pays only
+        // a quick no-op node spawn. Idempotent (keyed on the script name).
+        if (!hooks.PostToolUse) {
+            hooks.PostToolUse = [];
+        }
+        const postToolUseRec = hooks.PostToolUse;
+        this.migrateSettingsHookPaths(postToolUseRec, result);
+        const hasWsRecorder = postToolUseRec.some(e => e.hooks?.some(h => h.command?.includes('working-set-artifact-recorder.js')));
+        if (!hasWsRecorder) {
+            postToolUseRec.push({
+                matcher: 'Write|Edit|MultiEdit',
+                hooks: [{
+                        type: 'command',
+                        command: 'node ${CLAUDE_PROJECT_DIR}/.instar/hooks/instar/working-set-artifact-recorder.js',
+                        timeout: 5000,
+                    }],
+            });
+            patched = true;
+            result.upgraded.push('.claude/settings.json: added PostToolUse Write/Edit matcher (working-set artifact recorder)');
+        }
+        else {
+            result.skipped.push('.claude/settings.json: PostToolUse working-set recorder already present');
+        }
         // Clean up legacy PostToolUse session-start (was noisy — fired every tool use)
         if (hooks.PostToolUse) {
             const postToolUse = hooks.PostToolUse;
@@ -9855,6 +9888,35 @@ except Exception:
   fi
 fi
 
+# WORKING-SET ARTIFACT grounding (spec: intelligent-working-set-lazy-sync.md, Layer-3 /
+# Component6). Fetches /coherence/working-set/session-context for THIS topic and injects the
+# <replicated-untrusted-data source="working-set-artifacts"> block so the agent is GROUNDED
+# that interactive artifacts it recorded for this conversation exist (the whole point on a
+# topic-move: "you wrote these; re-verify/fetch them"). ADVISORY ONLY — a path is untrusted
+# data, never an instruction. Fail-open: no topic / route 503 (feature dark / manager unwired) /
+# no ready artifacts (present:false) / unreachable -> silent skip; -sf makes a non-2xx emit
+# nothing, so an absent/empty/oversized manifest degrades to no-block.
+if [ -n "\$INSTAR_TELEGRAM_TOPIC" ] && [ -n "\$PORT" ] && [ -n "\$TOKEN" ]; then
+  WS_ART_RESPONSE=\$(curl -sf --max-time 4 -H "Authorization: Bearer \$TOKEN" \\
+    "http://localhost:\${PORT}/coherence/working-set/session-context?topic=\${INSTAR_TELEGRAM_TOPIC}" 2>/dev/null)
+  if [ -n "\$WS_ART_RESPONSE" ]; then
+    WS_ART_BLOCK=\$(echo "\$WS_ART_RESPONSE" | python3 -c "
+import sys, json
+try:
+    d = json.load(sys.stdin)
+    if d.get('present') and d.get('block'):
+        print(d['block'])
+except Exception:
+    pass
+" 2>/dev/null)
+    if [ -n "\$WS_ART_BLOCK" ]; then
+      echo ""
+      echo "\$WS_ART_BLOCK"
+      echo ""
+    fi
+  fi
+fi
+
 # SESSION BOOT SELF-KNOWLEDGE injection (spec: session-boot-self-knowledge.md).
 # Fetches /self-knowledge/session-context and injects the deterministic "what I
 # already have" block: vault secret NAMES (never values) + self-asserted
@@ -11081,6 +11143,38 @@ except Exception:
   fi
 fi
 
+# WORKING-SET ARTIFACT grounding twin (Compaction Parity — intelligent-working-set-lazy-sync
+# Layer-3). Mirrors the session-start injection so after a compaction the agent is RE-grounded
+# on the interactive artifacts it recorded for this conversation. ADVISORY only (a path is
+# untrusted data). Fail-open: no topic / 503 (feature dark) / no ready artifacts / unreachable -> skip.
+if [ -n "\$INSTAR_TELEGRAM_TOPIC" ] && [ -f "$INSTAR_DIR/config.json" ]; then
+  WS_ART_PORT=\${PORT:-\$(grep -oE '"port"[[:space:]]*:[[:space:]]*[0-9]+' "$INSTAR_DIR/config.json" | head -1 | grep -oE '[0-9]+' | head -1)}
+  WS_ART_TOKEN="\${INSTAR_AUTH_TOKEN:-}"
+  if [ -z "\$WS_ART_TOKEN" ]; then
+    WS_ART_TOKEN=\$(python3 -c "import json; v=json.load(open('$INSTAR_DIR/config.json')).get('authToken',''); print(v if isinstance(v, str) else '')" 2>/dev/null)
+  fi
+  if [ -n "\$WS_ART_PORT" ] && [ -n "\$WS_ART_TOKEN" ]; then
+    WS_ART_RESPONSE=\$(curl -sf --max-time 4 --connect-timeout 1 -H "Authorization: Bearer \$WS_ART_TOKEN" \\
+      "http://localhost:\${WS_ART_PORT}/coherence/working-set/session-context?topic=\${INSTAR_TELEGRAM_TOPIC}" 2>/dev/null)
+    if [ -n "\$WS_ART_RESPONSE" ]; then
+      WS_ART_BLOCK=\$(echo "\$WS_ART_RESPONSE" | python3 -c "
+import sys, json
+try:
+    d = json.load(sys.stdin)
+    if d.get('present') and d.get('block'):
+        print(d['block'])
+except Exception:
+    pass
+" 2>/dev/null)
+      if [ -n "\$WS_ART_BLOCK" ]; then
+        echo ""
+        echo "\$WS_ART_BLOCK"
+        echo ""
+      fi
+    fi
+  fi
+fi
+
 echo "=== END IDENTITY RECOVERY ==="
 `;
     }
@@ -11848,6 +11942,87 @@ process.stdin.on('end', async () => {
   }
   process.exit(0); // ALWAYS exit 0 — never block a turn
 });
+`;
+    }
+    getWorkingSetArtifactRecorderHook() {
+        return `#!/usr/bin/env node
+// Working-Set Artifact Recorder — PostToolUse Write/Edit hook (spec: intelligent-working-set-lazy-sync.md, F8).
+//
+// SIGNAL-ONLY / fire-and-forget: on a SUCCESSFUL Write/Edit/MultiEdit under the .instar/ jail,
+// POSTs {topicId, relPath} to the server's POST /coherence/working-set/record so the INTERACTIVE
+// artifact (a file the agent wrote conversationally, with NO autonomous run) enters the computed
+// working-set manifest — the exact case WorkingSetManifest.computeWorkingSet misses. It NEVER
+// blocks — ALWAYS exit(0), pass or fail. Records NOTHING for a file OUTSIDE the .instar/ jail
+// (project files are git-synced; F10) or when the feature is off (code-default OFF ⇒ dark:
+// coherenceJournal.workingSet.recordInteractive). relPath is stateDir-relative + forward-slash
+// normalized — the exact convention computeWorkingSet Source-3 resolves (path.resolve(stateDir,rel)).
+//
+// ESM-safe: node: imports INSIDE the async handler (works in BOTH CJS and ESM host agents); a
+// bare top-level require(...) crashes an ESM-mode agent — see the 2026-05-27 silent-stall postmortem.
+
+let data = '';
+process.stdin.on('data', (chunk) => (data += chunk));
+process.stdin.on('end', async () => {
+  try {
+    const { readFileSync } = await import('node:fs');
+    const { join, resolve, relative, isAbsolute } = await import('node:path');
+
+    const projectDir = process.env.CLAUDE_PROJECT_DIR || '.';
+    let serverPort = 4040;
+    let authToken = '';
+    let enabled = false;
+    try {
+      const cfg = JSON.parse(readFileSync(join(projectDir, '.instar', 'config.json'), 'utf-8'));
+      serverPort = cfg.port || 4040;
+      authToken = cfg.authToken || '';
+      enabled = !!(cfg.coherenceJournal && cfg.coherenceJournal.workingSet && cfg.coherenceJournal.workingSet.recordInteractive);
+    } catch {}
+    if (!enabled) process.exit(0);
+
+    const input = JSON.parse(data);
+    const tool = input.tool_name || '';
+    if (tool !== 'Write' && tool !== 'Edit' && tool !== 'MultiEdit') process.exit(0);
+    // A failed tool-call records nothing (F8) — deletes are NOT inferred from a write.
+    const resp = input.tool_response;
+    if (resp && (resp.error || resp.success === false)) process.exit(0);
+
+    const filePath = input.tool_input && input.tool_input.file_path;
+    if (!filePath || typeof filePath !== 'string') process.exit(0);
+
+    // Conversation id — key from INSTAR_CONVERSATION_ID ONLY (a shared/lifeline session carries
+    // none → records nothing, a safe miss). Number.isFinite admits a minted-negative (Slack) id.
+    const topicRaw = process.env.INSTAR_CONVERSATION_ID;
+    if (!topicRaw) process.exit(0);
+    const topicId = parseInt(topicRaw, 10);
+    if (!Number.isFinite(topicId)) process.exit(0);
+
+    // Derive relPath vs the .instar/ jail (stateDir-relative). Outside the jail ⇒ skip (F10).
+    const stateDir = resolve(projectDir, '.instar');
+    const rawRel = relative(stateDir, resolve(filePath));
+    if (!rawRel || rawRel.startsWith('..') || isAbsolute(rawRel)) process.exit(0);
+    const segs = rawRel.split(/[/\\\\]+/);
+    if (segs.includes('.git')) process.exit(0); // never a git internal
+    const relPath = segs.join('/'); // forward-slash normalized for cross-machine identity
+
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5000);
+    try {
+      await fetch('http://127.0.0.1:' + serverPort + '/coherence/working-set/record', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + authToken },
+        body: JSON.stringify({ topicId, relPath }),
+        signal: controller.signal,
+      });
+    } catch {
+      // network/timeout — fire-and-forget, ignore
+    } finally {
+      clearTimeout(timeout);
+    }
+  } catch {
+    // bad stdin — ignore
+  }
+  process.exit(0); // ALWAYS exit 0 — never block a tool
+});
 `;
     }
     getPrHandLeaseGuardHook() {