@hearsay-tools/squawk 0.0.0-stage → 0.17.0-pr3058.5683

package/scripts/probe-session-env.ts

@@ -0,0 +1,8 @@
+const KEPT_ENV = new Set(['ENV_PASSTHROUGH', 'AGENT_ENV_FULL', 'CODEX_BIN'].flatMap(suffix => [`CEZ_${suffix}`, `HSQ_${suffix}`]));
+
+/** Live probes keep operator auth controls, but never inherit a task's session authority. */
+export function scrubProbeSessionEnv(env: NodeJS.ProcessEnv = process.env): void {
+  for (const name of Object.keys(env)) {
+    if ((/^(CEZ|HSQ)_/.test(name) && !KEPT_ENV.has(name)) || name.startsWith('CLAUDE_CODE_')) delete env[name];
+  }
+}

package/scripts/product-env.mjs

@@ -0,0 +1,6 @@
+// Shipped probes/mocks share the product accessor. Source checkouts need no build;
+// the published package contains dist/ and scripts/, without src/.
+import { existsSync } from 'node:fs';
+
+export const { productEnv } = await import(existsSync(new URL('../src/core/product-env.ts', import.meta.url))
+  ? '../src/core/product-env.ts' : '../dist/core/product-env.js');

package/scripts/product-identity.mjs

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import { productIdentity } from '../src/home/identity.ts';
+
+const args = process.argv.slice(2);
+if (args.length === 0) {
+  console.log(JSON.stringify(productIdentity()));
+} else if (args.length === 2 && args[0] === '--rebrand' && ['on', 'off'].includes(args[1])) {
+  console.log(JSON.stringify(productIdentity(args[1] === 'on')));
+} else {
+  console.error('Usage: node product-identity.mjs [--rebrand on|off]');
+  process.exitCode = 1;
+}

package/scripts/record-mock-wires.mjs

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+// npm run mock:wire -- <output-directory> [runner] [scenario]
+// Uses an explicit Vitest config because HARNESS_ADAPTERS imports Vitest testkits.
+// This evidence collector is never included in the normal unit suite.
+import { spawnSync } from 'node:child_process';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import { dirname, join, resolve } from 'node:path';
+const require = createRequire(import.meta.url);
+const [directory, runner = '', scenario = ''] = process.argv.slice(2);
+if (!directory) { console.error('Usage: npm run mock:wire -- <output-directory> [runner] [scenario]'); process.exit(64); }
+const result = spawnSync(process.execPath, [join(dirname(require.resolve('vitest/package.json')), 'vitest.mjs'), 'run', '--config',
+  fileURLToPath(new URL('./mock-wire-evidence.config.mjs', import.meta.url))], {
+  stdio: 'inherit', env: { ...process.env, MOCK_WIRE_OUTPUT_DIR: resolve(directory), MOCK_WIRE_RUNNER: runner, MOCK_WIRE_SCENARIO: scenario },
+});
+process.exit(result.status ?? 1);

package/scripts/seed-archive-profile.ts

@@ -0,0 +1,53 @@
+import { setRunStatus } from '../src/runs/run-store.testkit.ts';
+/** Repro fixture for #657: 12 archiveable parents, 48 owned workers, 200 review rows.
+ * Run only against an empty scratch repository:
+ * `tsx packages/cezar/scripts/seed-archive-profile.ts <scratch-repo>`. */
+import { randomUUID } from 'node:crypto';
+import { join } from 'node:path';
+import { RunStore } from '../src/runs/store.ts';
+
+const root = process.argv[2];
+if (!root) throw new Error('Pass the path to an empty scratch repository');
+const store = RunStore.open(join(root, '.ai/cezar'));
+if (store.listRunSummaries().runs.length) throw new Error('Scratch repository already contains runs');
+
+for (let p = 0; p < 12; p++) {
+  const parent = store.createRun({
+    title: `Profile parent ${p + 1}`, task: 'Task '.repeat(300), workflow: 'quick-task',
+    steps: [{ id: 'work', name: 'Work', kind: 'agent' }],
+  });
+  setRunStatus(store, parent.id, 'done', { finishedAt: '2026-01-01T00:00:00.000Z',
+    delegation: { role: 'root', permissions: ['spawn'], receipts: [] },
+  });
+  for (let w = 0; w < 4; w++) {
+    const workerId = randomUUID();
+    const worker = store.createOwnedRun(
+      {
+        title: `Profile worker ${p + 1}-${w + 1}`, task: 'Worker task '.repeat(150),
+        workflow: 'quick-task', runner: 'claude',
+        steps: [{ id: 'task', name: 'Task', kind: 'agent' }],
+      },
+      parent.id,
+      randomUUID(),
+      {
+        role: 'worker', permissions: [], parentRunId: parent.id,
+        workspace: {
+          ownerRunId: workerId, resourceId: randomUUID(), kind: 'owned-isolated',
+          path: `/managed/${workerId}`, branch: `cez/${workerId.slice(0, 8)}`,
+          baselineSha: 'a'.repeat(40),
+        },
+      },
+      'a'.repeat(64),
+    );
+    setRunStatus(store, worker.id, 'running');
+  }
+}
+for (let i = 0; i < 200; i++) {
+  const extra = store.createRun({
+    title: `Background task ${i + 1}`, task: 'Background task '.repeat(100),
+    workflow: 'quick-task', steps: [{ id: 'work', name: 'Work', kind: 'agent' }],
+  });
+  setRunStatus(store, extra.id, 'review');
+}
+console.log(JSON.stringify({ root, runs: store.listRunSummaries().runs.length, finished: 12 }));
+store.close();

package/scripts/sync-readme.mjs

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+// Copy the repo's README into this package before it is built/packed.
+//
+// There is exactly one README (the repo root's): it is the project's GitHub front page AND the
+// npm page for `@wjarka/cezarion`, and those must not be allowed to drift into two documents
+// saying different things about the same tool. `files` can only reference paths inside the
+// package, so the one source is copied in rather than referenced out — the copy is gitignored,
+// regenerated by every build, and never edited by hand.
+//
+// Runs as `prebuild`, so `npm run build` (and the release pipeline, which builds first) always
+// packs a current copy. `check:pack` is the gate that notices if this ever stops happening.
+
+import { copyFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const repoRoot = path.resolve(packageRoot, '../..');
+
+copyFileSync(path.join(repoRoot, 'README.md'), path.join(packageRoot, 'README.md'));

package/scripts/test-process-usage.mjs

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+// Unit check for the pure half of src/core/process-usage.ts (#348): ps-output
+// parsing + process-tree aggregation against canned `ps -axo pid=,ppid=,rss=,%cpu=`
+// output. Dependency-free; needs `npm run build` first (imports from dist/).
+//   node scripts/test-process-usage.mjs
+
+import assert from 'node:assert/strict';
+import { aggregateTreeUsage, parsePsOutput } from '../dist/core/process-usage.js';
+
+// Canned snapshot: two registered roots (100, 200) plus unrelated noise.
+// Root 100 owns a 3-level tree: 100 → 110 → 111, and 100 → 120.
+const PS_OUTPUT = `
+    1     0  1200   0.1
+  100     1 50000  10.0
+  110   100 20000   5.5
+  111   110  8000   0.0
+  120   100  4000   2.5
+  200     1 30000  50.0
+  210   200 10000  25.0
+  999     1 70000  99.0
+garbage line that ps should never emit
+  300   1
+`;
+
+const procs = parsePsOutput(PS_OUTPUT);
+assert.equal(procs.length, 8, 'parses 8 well-formed rows, skips malformed ones');
+assert.deepEqual(procs[1], { pid: 100, ppid: 1, rssKb: 50000, cpuPct: 10 });
+
+// Root 100: 4 processes across 3 levels; rss in KB × 1024 → bytes.
+const a = aggregateTreeUsage(procs, 100);
+assert.deepEqual(a, {
+  cpuPct: 18,
+  rssBytes: (50000 + 20000 + 8000 + 4000) * 1024,
+  procCount: 4,
+});
+
+// Root 200: 2 processes; the other tree's processes never leak in.
+const b = aggregateTreeUsage(procs, 200);
+assert.deepEqual(b, { cpuPct: 75, rssBytes: (30000 + 10000) * 1024, procCount: 2 });
+
+// A root missing from the snapshot (process exited) → null, not zeros.
+assert.equal(aggregateTreeUsage(procs, 12345), null);
+
+// A leaf works as a root of its own single-node tree.
+assert.deepEqual(aggregateTreeUsage(procs, 111), { cpuPct: 0, rssBytes: 8000 * 1024, procCount: 1 });
+
+console.log('process-usage: all assertions passed');

package/scripts/transcript-facts-fixture.mjs

@@ -0,0 +1,53 @@
+/** Shared cold fixture for the isolated lag, HTTP, and installed-package proofs. */
+import assert from 'node:assert/strict';
+import { mkdirSync, writeFileSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { brotliCompressSync, constants } from 'node:zlib';
+
+export async function seedColdHistories(dataDir, runtime) {
+  const { RunDatabase, RUNS_DB_FILE, RUNS_IMPORT_COMPLETE_KEY } = await import(new URL('runs/run-database.' + runtime.ext, runtime.url));
+  const { encodeRunRow } = await import(new URL('runs/run-row.' + runtime.ext, runtime.url));
+  mkdirSync(join(dataDir, 'runs'), { recursive: true });
+  const fixtures = [];
+  const rows = [];
+  for (let i = 0; i < 700; i++) {
+    const id = `00000000-0000-4000-8000-${String(i).padStart(12, '0')}`;
+    const events = i === 0 ? 100_000 : 8;
+    const text = Array.from({ length: events }, (_, n) => JSON.stringify({
+      type: 'text', seq: n + 1, ts: '2026-10-08T00:00:00.000Z', text: 'history payload '.repeat(i === 0 ? 24 : 2),
+    }) + '\n').join('');
+    const archived = i % 2 === 1;
+    const bytes = Buffer.byteLength(text);
+    const body = archived ? brotliCompressSync(Buffer.from(text), { params: { [constants.BROTLI_PARAM_QUALITY]: 1 } }) : text;
+    writeFileSync(join(dataDir, 'runs', `${id}.ndjson${archived ? '.br' : ''}`), body);
+    fixtures.push({ id, events, bytes, archived, diskBytes: Buffer.byteLength(body) });
+    rows.push(encodeRunRow({ id, title: 'cold history', task: 'fixture', workflow: 'quick-task', status: 'done',
+      createdAt: '2026-10-08T00:00:00.000Z', tokensUsed: 0, archived: false, steps: [],
+      delegation: { role: 'root', permissions: [], receipts: [], conversation: { messages: [], outcomes: [] } },
+    }));
+  }
+  const db = RunDatabase.open(join(dataDir, RUNS_DB_FILE));
+  try { db.transaction({ upserts: rows, deletes: [], meta: { [RUNS_IMPORT_COMPLETE_KEY]: JSON.stringify({ source: 'responsiveness fixture', records: rows.length }) } }); }
+  finally { db.close(); }
+  assert.equal(readdirSync(join(dataDir, 'runs')).filter(name => name.endsWith('.facts.json')).length, 0);
+  return fixtures;
+}
+
+export function verifyFacts(dataDir, fixtures, store) {
+  for (const fixture of fixtures) {
+    const facts = JSON.parse(readFileSync(join(dataDir, 'runs', `${fixture.id}.facts.json`), 'utf8'));
+    assert.equal(facts.version, 1);
+    assert.equal(facts.bytes, fixture.bytes);
+    assert.equal(facts.lastSeq, fixture.events);
+    assert.deepEqual(store.transcriptFacts(fixture.id), facts);
+    if (fixture.archived) {
+      const stat = statSync(join(dataDir, 'runs', `${fixture.id}.ndjson.br`));
+      assert.deepEqual(facts.archive, { size: stat.size, mtimeMs: stat.mtimeMs, ino: stat.ino });
+    } else assert.equal(facts.archive, undefined);
+  }
+  assert.equal(readdirSync(join(dataDir, 'runs')).filter(name => name.endsWith('.facts.json')).length, fixtures.length);
+  return { histories: fixtures.length, plain: fixtures.filter(f => !f.archived).length,
+    brotli: fixtures.filter(f => f.archived).length, events: fixtures.reduce((n, f) => n + f.events, 0),
+    decodedBytes: fixtures.reduce((n, f) => n + f.bytes, 0), diskBytes: fixtures.reduce((n, f) => n + f.diskBytes, 0),
+    largestEvents: fixtures[0].events, largestBytes: fixtures[0].bytes, coldSidecars: 0, sidecars: fixtures.length };
+}

package/scripts/transcript-facts-timing.mjs

@@ -0,0 +1,42 @@
+/** Main-thread measurements only: worker CPU does not count as loop blocking. */
+import { readFileSync } from 'node:fs';
+
+export function readQueueWaitMs({ read = readFileSync, platform = process.platform } = {}) {
+  // Linux schedstat field 2 is cumulative run-queue wait in nanoseconds.
+  if (platform !== 'linux') return null;
+  try {
+    const waitNs = Number(read('/proc/thread-self/schedstat', 'utf8').trim().split(/\s+/)[1]);
+    return Number.isFinite(waitNs) && waitNs >= 0 ? waitNs / 1e6 : null;
+  }
+  catch { return null; /* Optional diagnostic on restricted procfs mounts. */ }
+}
+
+export function timingSnapshot({ now = () => performance.now(), readQueue = readQueueWaitMs,
+  readCpu = () => process.threadCpuUsage() } = {}) {
+  const cpu = readCpu();
+  const queueBeforeMs = readQueue();
+  const at = now();
+  const queueAfterMs = readQueue();
+  return { at, cpuMs: (cpu.user + cpu.system) / 1000, queueBeforeMs, queueAfterMs };
+}
+
+export function timingDelta(start, end) {
+  const elapsedMs = end.at - start.at;
+  const mainThreadCpuMs = end.cpuMs - start.cpuMs;
+  // Previous AFTER -> next BEFORE is contained in the wall-clock interval.
+  // Subtract only this inner queue-wait delta. A pause between a scheduler
+  // read and the clock must never credit wait from outside the interval.
+  const queueWaitMs = start.queueAfterMs === null || end.queueBeforeMs === null ? null
+    : Math.max(0, Math.min(elapsedMs, end.queueBeforeMs - start.queueAfterMs));
+  // Residual includes timer/IO sleep and measurement overhead, not just IO.
+  return { elapsedMs, mainThreadCpuMs, queueWaitMs,
+    blockedMs: queueWaitMs === null ? null : Math.max(0, elapsedMs - mainThreadCpuMs - queueWaitMs) };
+}
+
+/** Timer samples exclude their planned sleep; requests have no planned sleep. */
+export function blockingBudget(sample, periodMs = 0) {
+  const mode = sample.queueWaitMs === null ? 'cpu-only' : 'scheduler-adjusted';
+  const blockingMs = sample.queueWaitMs === null ? sample.mainThreadCpuMs
+    : Math.max(0, sample.elapsedMs - periodMs - sample.queueWaitMs);
+  return { mode, blockingMs: Math.max(0, periodMs > 0 ? Math.max(sample.mainThreadCpuMs, blockingMs) : blockingMs) };
+}

package/scripts/voice-replay.ts

@@ -0,0 +1,50 @@
+// The voice replay set against the live Jev engine (hearsay-tools/cezarion#1463). Not part of any
+// test run: it costs API calls and needs TYPESAFE_API_KEY in the environment. From packages/cezar:
+//
+//   node --import tsx scripts/voice-replay.ts
+//
+// For each case it prints the expected and actual decision, each target's min and mean word
+// confidence, the latency and the input tokens, and exits 1 on any mismatch. It never prints the key.
+import { JevVoiceEngine } from '../src/voice/jev-engine.ts';
+import type { DecisionEngine } from '../src/voice/engine.ts';
+import { REPLAY_CASES, mismatch, replayDecision, targetConfidences } from '../src/voice/replay-set.testkit.ts';
+
+const apiKey = process.env.TYPESAFE_API_KEY;
+if (!apiKey) {
+  console.error('TYPESAFE_API_KEY is not set.');
+  process.exit(2);
+}
+const jev = new JevVoiceEngine({ apiKey });
+
+let failed = 0;
+const latencies: number[] = [];
+for (const replay of REPLAY_CASES) {
+  let inputTokens: number | undefined;
+  const engine: DecisionEngine = {
+    id: jev.id,
+    async decide(input, signal) {
+      const result = await jev.decide(input, signal);
+      inputTokens = result.inputTokens;
+      return result;
+    },
+  };
+  try {
+    const { decision, answers, latencyMs } = await replayDecision(replay, engine);
+    latencies.push(latencyMs);
+    const wrong = mismatch(replay.expect, decision);
+    if (wrong) failed += 1;
+    console.log(`${wrong ? 'FAIL' : 'ok  '} ${replay.name} — "${replay.sentence}" (${latencyMs} ms, ${inputTokens ?? '?'} in-tokens)`);
+    if (wrong) console.log(`     ${wrong}`);
+    const { decisionId: _id, ...shown } = decision;
+    console.log(`     decision: ${JSON.stringify(shown)}`);
+    for (const [label, { min, mean }] of Object.entries(targetConfidences(replay.sentence, answers))) {
+      console.log(`     ${label}: min ${min.toFixed(2)}, mean ${mean.toFixed(2)}`);
+    }
+  } catch (error) {
+    failed += 1;
+    console.log(`FAIL ${replay.name} — ${error instanceof Error ? error.message : 'engine error'}`);
+  }
+}
+const range = latencies.length ? `${Math.min(...latencies)}–${Math.max(...latencies)} ms` : 'n/a';
+console.log(`\n${REPLAY_CASES.length - failed}/${REPLAY_CASES.length} cases passed; latency ${range}`);
+process.exit(failed === 0 ? 0 : 1);

package/scripts/windows-workspace-identity.cs

@@ -0,0 +1,208 @@
+// Windows counterpart of workspace.ts's private, no-follow identity file operations.
+// Loaded by the adjacent PowerShell entry point; shipped with the CLI.
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Security.AccessControl;
+using System.Security.Principal;
+using System.Text;
+using Microsoft.Win32.SafeHandles;
+
+public static class CezWorkspaceIdentity {
+  const uint ReadControl = 0x20000, ReadAttributes = 0x80, GenericRead = 0x80000000, GenericWrite = 0x40000000, Delete = 0x10000;
+  const uint OpenReparse = 0x200000, BackupSemantics = 0x2000000, ReparsePoint = 0x400, DirectoryAttribute = 0x10;
+  const uint ShareRead = 1, ShareWrite = 2, ShareDelete = 4, OpenExisting = 3, CreateNew = 1;
+  const int FullControl = 0x1f01ff;
+  static readonly string User = WindowsIdentity.GetCurrent().User.Value;
+  [StructLayout(LayoutKind.Sequential)] struct SecurityAttributes { public int Length; public IntPtr Descriptor; public int Inherit; }
+  [StructLayout(LayoutKind.Sequential)] struct FileInformation {
+    public uint Attributes; public System.Runtime.InteropServices.ComTypes.FILETIME Creation, Access, Write;
+    public uint Volume, SizeHigh, SizeLow, Links, IndexHigh, IndexLow;
+  }
+  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)] struct RenameInformation {
+    public uint Replace; public IntPtr Root; public uint Length; public char Name;
+  }
+  [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+  static extern SafeFileHandle CreateFileW(string path, uint access, uint share, IntPtr security, uint creation, uint flags, IntPtr template);
+  [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+  static extern bool CreateDirectoryW(string path, ref SecurityAttributes security);
+  [DllImport("kernel32.dll", SetLastError = true)]
+  static extern bool GetFileInformationByHandle(SafeFileHandle file, out FileInformation information);
+  [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+  static extern uint GetFinalPathNameByHandleW(SafeFileHandle file, StringBuilder path, uint size, uint flags);
+  [DllImport("advapi32.dll")]
+  static extern uint GetSecurityInfo(SafeFileHandle file, int type, uint information, out IntPtr owner, out IntPtr group, out IntPtr dacl, out IntPtr sacl, out IntPtr descriptor);
+  [DllImport("advapi32.dll")]
+  static extern uint GetSecurityDescriptorLength(IntPtr descriptor);
+  [DllImport("kernel32.dll")] static extern IntPtr LocalFree(IntPtr memory);
+  [DllImport("kernel32.dll", SetLastError = true)]
+  static extern bool SetFileInformationByHandle(SafeFileHandle file, int kind, IntPtr information, uint size);
+
+  sealed class PrivateSecurity : IDisposable {
+    GCHandle pinned; IntPtr attributes;
+    public SecurityAttributes Value;
+    public PrivateSecurity(bool directory) {
+      string inheritance = directory ? "OICI" : "";
+      var descriptor = new RawSecurityDescriptor("O:" + User + "D:P(A;" + inheritance + ";FA;;;" + User + ")(A;" + inheritance + ";FA;;;SY)(A;" + inheritance + ";FA;;;BA)");
+      byte[] bytes = new byte[descriptor.BinaryLength]; descriptor.GetBinaryForm(bytes, 0);
+      pinned = GCHandle.Alloc(bytes, GCHandleType.Pinned);
+      Value = new SecurityAttributes { Length = Marshal.SizeOf(typeof(SecurityAttributes)), Descriptor = pinned.AddrOfPinnedObject() };
+      attributes = Marshal.AllocHGlobal(Value.Length); Marshal.StructureToPtr(Value, attributes, false);
+    }
+    public IntPtr Pointer { get { return attributes; } }
+    public void Dispose() { Marshal.FreeHGlobal(attributes); pinned.Free(); }
+  }
+
+  static string Canonical(string path) {
+    // Device paths, streams and UNC shares are outside this local receipt store.
+    if (path.Length < 3 || !Char.IsLetter(path[0]) || path[1] != ':' || (path[2] != '\\' && path[2] != '/'))
+      throw new IOException("Identity path must be on a local drive");
+    if (path.Substring(2).IndexOf(':') >= 0) throw new IOException("Identity path contains a stream");
+    string full = Path.GetFullPath(path);
+    return full.Length > 3 ? full.TrimEnd('\\') : full;
+  }
+  static SafeFileHandle Open(string path, uint access, uint share, bool missingAllowed) {
+    var file = CreateFileW(path, access, share, IntPtr.Zero, OpenExisting, OpenReparse | BackupSemantics, IntPtr.Zero);
+    if (!file.IsInvalid) return file;
+    int error = Marshal.GetLastWin32Error(); file.Dispose();
+    if (missingAllowed && (error == 2 || error == 3)) return null;
+    throw new Win32Exception(error, "Cannot open workspace identity: " + path);
+  }
+  static FileInformation CheckObject(SafeFileHandle file, string path, bool directory) {
+    FileInformation info;
+    if (!GetFileInformationByHandle(file, out info)) throw new Win32Exception();
+    if ((info.Attributes & ReparsePoint) != 0 || ((info.Attributes & DirectoryAttribute) != 0) != directory)
+      throw new IOException("Redirected or wrong-kind workspace identity");
+    if (!directory && info.Links != 1) throw new IOException("Linked workspace identity");
+    var final = new StringBuilder(32768);
+    uint length = GetFinalPathNameByHandleW(file, final, (uint)final.Capacity, 0);
+    if (length == 0 || length >= final.Capacity) throw new IOException("Cannot resolve workspace identity handle");
+    string name = final.ToString(); if (name.StartsWith("\\\\?\\")) name = name.Substring(4);
+    if (!String.Equals(Canonical(name), path, StringComparison.OrdinalIgnoreCase)) throw new IOException("Workspace identity handle names another path");
+    return info;
+  }
+  static void CheckPrivate(SafeFileHandle file) {
+    IntPtr owner, group, dacl, sacl, descriptor;
+    uint error = GetSecurityInfo(file, 1, 5, out owner, out group, out dacl, out sacl, out descriptor);
+    if (error != 0) throw new Win32Exception((int)error);
+    try {
+      byte[] bytes = new byte[GetSecurityDescriptorLength(descriptor)]; Marshal.Copy(descriptor, bytes, 0, bytes.Length);
+      var security = new RawSecurityDescriptor(bytes, 0);
+      if (security.Owner == null || security.Owner.Value != User || security.DiscretionaryAcl == null ||
+          (security.ControlFlags & ControlFlags.DiscretionaryAclProtected) == 0) throw new IOException("Unprotected workspace identity");
+      bool userFullControl = false;
+      foreach (GenericAce entry in security.DiscretionaryAcl) {
+        var ace = entry as CommonAce;
+        if (ace == null || ace.IsCallback || ace.AceQualifier != AceQualifier.AccessAllowed) throw new IOException("Unknown workspace identity ACL");
+        string sid = ace.SecurityIdentifier.Value;
+        if (sid != User && sid != "S-1-5-18" && sid != "S-1-5-32-544") throw new IOException("Broad workspace identity ACL");
+        if (sid == User && (ace.AceFlags & AceFlags.InheritOnly) == 0 && (ace.AccessMask & FullControl) == FullControl) userFullControl = true;
+      }
+      if (!userFullControl) throw new IOException("Workspace identity owner lacks control");
+    } finally { LocalFree(descriptor); }
+  }
+
+  // Pin every ancestor without FILE_SHARE_DELETE. Opening each component with
+  // OPEN_REPARSE_POINT rejects junctions too, including intermediate components.
+  sealed class Parents : IDisposable {
+    readonly List<SafeFileHandle> handles = new List<SafeFileHandle>();
+    public Parents(string path) {
+      try {
+        string directory = Path.GetDirectoryName(path), current = Path.GetPathRoot(path);
+        Pin(current);
+        foreach (string part in directory.Substring(current.Length).Split(new char[] { '\\' }, StringSplitOptions.RemoveEmptyEntries)) {
+          current = Path.Combine(current, part); Pin(current);
+        }
+      } catch { Dispose(); throw; }
+    }
+    void Pin(string path) {
+      var file = Open(path, ReadAttributes, ShareRead | ShareWrite, false);
+      handles.Add(file); CheckObject(file, Canonical(path), true);
+    }
+    public void Dispose() { for (int i = handles.Count - 1; i >= 0; i--) handles[i].Dispose(); }
+  }
+  static SafeFileHandle PrivateFile(string path, bool missingAllowed, uint share) {
+    var file = Open(path, GenericRead | ReadControl, share, missingAllowed);
+    if (file == null) return null;
+    try { CheckObject(file, path, false); CheckPrivate(file); return file; }
+    catch { file.Dispose(); throw; }
+  }
+  static void PrivateDirectory(string path) {
+    using (var file = Open(path, ReadAttributes | ReadControl, ShareRead | ShareWrite, false)) {
+      CheckObject(file, path, true); CheckPrivate(file);
+    }
+  }
+  public static void Directory(string input, bool create) {
+    string path = Canonical(input);
+    using (var parents = new Parents(path)) {
+      if (create) using (var security = new PrivateSecurity(true)) {
+        if (!CreateDirectoryW(path, ref security.Value)) {
+          int error = Marshal.GetLastWin32Error(); if (error != 183) throw new Win32Exception(error);
+        }
+      }
+      using (var file = Open(path, ReadAttributes | ReadControl, ShareRead | ShareWrite, !create)) {
+        if (file != null) { CheckObject(file, path, true); CheckPrivate(file); }
+      }
+    }
+  }
+  public static string Read(string input, int cap, bool privateParent) {
+    string path = Canonical(input);
+    using (var parents = new Parents(path)) {
+      if (privateParent) PrivateDirectory(Path.GetDirectoryName(path));
+      using (var file = PrivateFile(path, false, ShareRead)) {
+        var info = CheckObject(file, path, false);
+        if (cap < 0 || cap > 16384 || info.SizeHigh != 0 || info.SizeLow > cap) throw new IOException("Oversized workspace identity");
+        using (var stream = new FileStream(file, FileAccess.Read)) {
+          byte[] bytes = new byte[cap + 1]; int count = 0, read;
+          while (count < bytes.Length && (read = stream.Read(bytes, count, bytes.Length - count)) != 0) count += read;
+          if (count > cap) throw new IOException("Oversized workspace identity");
+          return Convert.ToBase64String(bytes, 0, count);
+        }
+      }
+    }
+  }
+  static SafeFileHandle Create(string path) {
+    using (var security = new PrivateSecurity(false)) {
+      var file = CreateFileW(path, GenericWrite | ReadControl | Delete, 0, security.Pointer, CreateNew, OpenReparse, IntPtr.Zero);
+      if (file.IsInvalid) { int error = Marshal.GetLastWin32Error(); file.Dispose(); throw new Win32Exception(error); }
+      try { CheckObject(file, path, false); CheckPrivate(file); return file; }
+      catch { file.Dispose(); throw; }
+    }
+  }
+  static void Rename(SafeFileHandle file, string path) {
+    byte[] name = Encoding.Unicode.GetBytes(path);
+    int offset = (int)Marshal.OffsetOf(typeof(RenameInformation), "Name");
+    // The Win32 path conversion needs a terminated string; Length excludes its NUL.
+    int size = offset + name.Length + 2;
+    IntPtr memory = Marshal.AllocHGlobal(size);
+    try {
+      // Zero padding as well as RootDirectory; use the pinned absolute destination.
+      // REPLACE_IF_EXISTS | POSIX_SEMANTICS permits replacing the destination while
+      // its verified read handle stays open. Never close it to make rename work.
+      Marshal.Copy(new byte[size], 0, memory, size); Marshal.WriteInt32(memory, 3);
+      Marshal.WriteInt32(memory, (int)Marshal.OffsetOf(typeof(RenameInformation), "Length"), name.Length);
+      Marshal.Copy(name, 0, IntPtr.Add(memory, offset), name.Length);
+      if (!SetFileInformationByHandle(file, 22 /* FileRenameInfoEx */, memory, (uint)size)) {
+        int error = Marshal.GetLastWin32Error(); throw new Win32Exception(error, "Cannot rename workspace checkpoint (" + error + ")");
+      }
+    } finally { Marshal.FreeHGlobal(memory); }
+  }
+  public static void Write(string input, string content, bool replace, bool privateParent) {
+    string path = Canonical(input); byte[] bytes = Convert.FromBase64String(content);
+    if (bytes.Length > 16384) throw new IOException("Oversized workspace identity");
+    using (var parents = new Parents(path)) {
+      // Only checkpoint replacement is allowed, inside the already-private store.
+      if (replace || privateParent) PrivateDirectory(Path.GetDirectoryName(path));
+      using (var previous = replace ? PrivateFile(path, true, ShareRead | ShareDelete) : null) {
+        string temporary = replace ? path + "." + Guid.NewGuid().ToString("N") + ".tmp" : path;
+        using (var file = Create(temporary))
+        using (var stream = new FileStream(file, FileAccess.Write)) {
+          stream.Write(bytes, 0, bytes.Length); stream.Flush(true);
+          if (replace) Rename(file, path);
+        }
+      }
+    }
+  }
+}

package/scripts/windows-workspace-identity.ps1

@@ -0,0 +1,10 @@
+$ErrorActionPreference = 'Stop'
+[Console]::InputEncoding = New-Object System.Text.UTF8Encoding($false)
+Add-Type -Path (Join-Path $PSScriptRoot 'windows-workspace-identity.cs')
+$request = [Console]::In.ReadToEnd() | ConvertFrom-Json
+switch ($request.operation) {
+  'directory' { [CezWorkspaceIdentity]::Directory($request.path, [bool]$request.create) }
+  'read' { [CezWorkspaceIdentity]::Read($request.path, [int]$request.cap, [bool]$request.privateParent) }
+  'write' { [CezWorkspaceIdentity]::Write($request.path, $request.content, [bool]$request.replace, [bool]$request.privateParent) }
+  default { throw 'Unknown workspace identity operation' }
+}

package/web/dist/assets/activity-motion-0wHCeUs7.css

@@ -0,0 +1 @@
+.activity-pulse{position:relative}.activity-pulse:after{content:"";background:var(--status-running);opacity:0;pointer-events:none;border-radius:9999px;animation:1.6s ease-out infinite activity-pulse;position:absolute;inset:2.5px}@keyframes activity-pulse{0%{opacity:.55;transform:scale(1)}to{opacity:0;transform:scale(2.6)}}.activity-breathe{animation:3s ease-in-out infinite activity-breathe}.activity-breathe-fast{animation:1.2s ease-in-out infinite activity-breathe}@keyframes activity-breathe{50%{opacity:.45}}.activity-sweep{pointer-events:none;background:linear-gradient(90deg, transparent, color-mix(in oklch, var(--status-running) 12%, transparent), transparent);animation:2.4s ease-in-out infinite activity-sweep;position:absolute;inset:0;transform:translate(-100%)}@keyframes activity-sweep{to{transform:translate(100%)}}.activity-glow{border-radius:inherit;pointer-events:none;box-shadow:0 0 0 4px color-mix(in oklch, var(--pending) 16%, transparent), 0 0 24px color-mix(in oklch, var(--pending) 14%, transparent);opacity:0;animation:2.6s ease-in-out infinite activity-glow;position:absolute;inset:-1px}@keyframes activity-glow{50%{opacity:1}}.activity-flash{border-radius:inherit;pointer-events:none;opacity:0;border-width:2px;animation:1.3s ease-out activity-flash;position:absolute;inset:-1px}@keyframes activity-flash{0%{opacity:1;transform:scale(1)}to{opacity:0;transform:scale(1.03)}}.activity-card-enter{animation:.7s ease-out activity-card-enter}@keyframes activity-card-enter{0%{opacity:0;transform:translateY(8px)scale(.98)}}.activity-card-leave{animation:.5s ease-in forwards activity-card-leave}@keyframes activity-card-leave{to{opacity:0;transform:scale(.96)}}.activity-row-enter{animation:.7s ease-out activity-row-enter}@keyframes activity-row-enter{0%{opacity:0;transform:translateY(-4px)}}.activity-row-fold{animation:.5s ease-in forwards activity-row-fold}@keyframes activity-row-fold{to{opacity:0;transform:translate(-8px)}}.activity-feed-enter{animation:.6s ease-out activity-feed-enter}@keyframes activity-feed-enter{0%{opacity:0;transform:translate(10px)}}.activity-row-flash{border-radius:inherit;pointer-events:none;opacity:0;animation:1.6s ease-out activity-row-flash;position:absolute;inset:0}@keyframes activity-row-flash{0%{opacity:.35}}.activity-slide{animation:.45s ease-out activity-slide}@keyframes activity-slide{0%{opacity:0;transform:translateY(4px)}}.activity-bump{animation:.5s ease-out activity-bump;display:inline-block}@keyframes activity-bump{0%{transform:scale(1.5)}}.activity-check-pass{animation:.8s ease-out activity-check-pass}@keyframes activity-check-pass{0%{transform:scaleY(2.4)}}.activity-march{animation:.9s linear infinite activity-march}@keyframes activity-march{to{stroke-dashoffset:-22px}}.activity-drift{animation:2.4s linear infinite activity-drift}@keyframes activity-drift{to{stroke-dashoffset:-16px}}.activity-line-in{animation:.8s ease-out activity-line-in}@keyframes activity-line-in{0%{opacity:0}}.activity-line-out{animation:.8s ease-in forwards activity-line-out}@keyframes activity-line-out{to{opacity:0}}[data-activity-paused] *,[data-activity-paused] :before,[data-activity-paused] :after{animation-play-state:paused!important}@media (prefers-reduced-motion:reduce){.activity-pulse:after,.activity-sweep,.activity-glow,.activity-flash,.activity-row-flash{display:none}.activity-breathe,.activity-breathe-fast,.activity-card-enter,.activity-card-leave,.activity-row-enter,.activity-row-fold,.activity-feed-enter,.activity-slide,.activity-bump,.activity-check-pass,.activity-march,.activity-drift,.activity-line-in,.activity-line-out{animation:none}}.activity-pulse[data-tone=success]:after{background:var(--success)}