@useorgx/wizard 0.1.56 → 0.1.57

package/dist/cli.js

@@ -2,12 +2,12 @@
 
 // src/cli.ts
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="02842523-d681-5cea-96aa-0f0c896e9fb5")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="8eca99e4-958f-5704-a1cb-bd96bbd10293")}catch(e){}}();
 import * as clack from "@clack/prompts";
 import { spawnSync as spawnSync5 } from "child_process";
-import { readFileSync as readFileSync8 } from "fs";
+import { readFileSync as readFileSync10 } from "fs";
 import { hostname } from "os";
-import { resolve as resolve3 } from "path";
+import { resolve as resolve4 } from "path";
 import { Command } from "commander";
 import pc3 from "picocolors";
 
@@ -187,6 +187,9 @@ import {
   writeFileSync
 } from "fs";
 import { dirname } from "path";
+function fileExists(path) {
+  return existsSync(path);
+}
 function readTextIfExists(path) {
   if (!existsSync(path)) return null;
   try {
@@ -831,7 +834,7 @@ function parsePairingPollResult(value) {
   };
 }
 function sleep(ms) {
-  return new Promise((resolve4) => setTimeout(resolve4, ms));
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
 }
 async function startBrowserPairing(options, fetchImpl) {
   const data = await fetchJson({
@@ -944,12 +947,12 @@ h1{font-size:1.5rem;color:#b91c1c}p{color:#555;margin-top:.5rem}</style>
 <p>Return to your terminal and try again.</p>
 </div></body></html>`;
 function tryListen(port, hostname2) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const server = createServer();
     server.once("error", reject);
     server.listen(port, hostname2, () => {
       server.removeListener("error", reject);
-      resolve4(server);
+      resolve5(server);
     });
   });
 }
@@ -978,7 +981,7 @@ async function startLocalAuthServer(options) {
   const successHtml = options.successHtml ?? DEFAULT_SUCCESS_HTML;
   const errorHtml = options.errorHtml ?? DEFAULT_ERROR_HTML;
   const { server, port } = await bindServer(options.preferredPort, hostname2);
-  const result = new Promise((resolve4, reject) => {
+  const result = new Promise((resolve5, reject) => {
     const timer = setTimeout(() => {
       server.close();
       reject(new Error("Timed out waiting for browser authorization."));
@@ -1021,7 +1024,7 @@ async function startLocalAuthServer(options) {
       res.writeHead(200, { "Content-Type": "text/html" }).end(successHtml);
       clearTimeout(timer);
       server.close();
-      resolve4({ code, state });
+      resolve5({ code, state });
     });
   });
   return { port, result };
@@ -3604,8 +3607,8 @@ function encodeRepoPath2(value) {
   return value.split("/").filter((segment) => segment.length > 0).map((segment) => encodeURIComponent(segment)).join("/");
 }
 function isLikelyRepoFilePath(path) {
-  const basename5 = path.split("/").pop() ?? path;
-  return basename5.includes(".") && !/^\.[^./]+$/.test(basename5);
+  const basename6 = path.split("/").pop() ?? path;
+  return basename6.includes(".") && !/^\.[^./]+$/.test(basename6);
 }
 function buildContentsUrl2(spec, path) {
   const encodedPath = encodeRepoPath2(path);
@@ -3881,7 +3884,7 @@ function formatCommandFailure(command, args, result) {
   return `${command} ${args.join(" ")} failed${result.exitCode >= 0 ? ` with exit code ${result.exitCode}` : ""}${detail ? `: ${detail}` : "."}`;
 }
 async function defaultCommandRunner(command, args) {
-  return await new Promise((resolve4) => {
+  return await new Promise((resolve5) => {
     const child = spawn(command, [...args], {
       env: process.env,
       stdio: ["ignore", "pipe", "pipe"]
@@ -3895,16 +3898,16 @@ async function defaultCommandRunner(command, args) {
       stderr += chunk.toString();
     });
     child.on("error", (error) => {
-      const errorCode = typeof error === "object" && error && "code" in error ? String(error.code) : void 0;
-      resolve4({
+      const errorCode2 = typeof error === "object" && error && "code" in error ? String(error.code) : void 0;
+      resolve5({
         exitCode: -1,
         stdout,
         stderr,
-        ...errorCode ? { errorCode } : {}
+        ...errorCode2 ? { errorCode: errorCode2 } : {}
       });
     });
     child.on("close", (code) => {
-      resolve4({
+      resolve5({
         exitCode: code ?? -1,
         stdout,
         stderr
@@ -6211,7 +6214,7 @@ function initializeWizardSentry() {
   Sentry.init({
     dsn,
     environment: process.env.ORGX_SENTRY_ENVIRONMENT || "production",
-    release: "useorgx-wizard@0.1.56",
+    release: "useorgx-wizard@0.1.57",
     tracesSampleRate: sampleRate(process.env.ORGX_SENTRY_TRACES_SAMPLE_RATE),
     enableLogs: true,
     sendDefaultPii: false,
@@ -13623,13 +13626,758 @@ function buildWorkGraphHookReplayPatch(readResult) {
 }
 
 // src/lib/runtime-hooks.ts
-import { copyFileSync, existsSync as existsSync9, mkdirSync as mkdirSync4 } from "fs";
+import { copyFileSync, existsSync as existsSync9, mkdirSync as mkdirSync4, readdirSync as readdirSync6 } from "fs";
 import { homedir as homedir3 } from "os";
-import { dirname as dirname5, join as join8 } from "path";
+import { dirname as dirname5, join as join8, resolve as resolve2 } from "path";
+
+// src/lib/session-summary-hook.ts
+var SESSION_SUMMARY_HOOK_MARKER = "orgx-session-summary.mjs";
+var SESSION_SUMMARY_ENDPOINT_PATH = "/api/v1/sessions/summary";
+var SESSION_SUMMARY_FALLBACK_ENDPOINT_PATH = "/api/v1/work-graph/reports";
+var SESSION_SUMMARY_SCHEMA_VERSION = "2026-08-07";
+var HOOK_OUTBOX_MAX_BYTES = 8 * 1024 * 1024;
+function buildSessionSummaryHookScriptContent() {
+  return `#!/usr/bin/env node
+// OrgX lean session-summary hook. Generated by @useorgx/wizard.
+//
+// Hot path (PostToolUse and friends): ONE small read-modify-write. No network.
+// Terminal (Stop / SessionEnd): ONE compact cumulative summary queue write.
+// A separate orgx-wizard hooks flush process owns all network delivery.
+//
+// NOTE ON Stop SEMANTICS: in Claude Code, Stop fires at every assistant turn
+// boundary, not only once at session end. Stop therefore writes a cumulative
+// snapshot and retains state. The ingest endpoint merges repeated snapshots by
+// session_id; SessionEnd, when the client sends it, queues the final snapshot
+// and clears local state.
+
+import { spawn } from "node:child_process";
+import { closeSync, fsyncSync, mkdirSync, openSync, readFileSync, writeFileSync, writeSync, rmSync, renameSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, dirname, basename } from "node:path";
+
+var SCHEMA_VERSION = "${SESSION_SUMMARY_SCHEMA_VERSION}";
+
+export function parseArgs(argv) {
+  var args = {};
+  for (var i = 0; i < argv.length; i++) {
+    var arg = argv[i];
+    if (arg.indexOf("--") !== 0) continue;
+    var eq = arg.indexOf("=");
+    if (eq < 0) args[arg.slice(2)] = "true";
+    else args[arg.slice(2, eq)] = arg.slice(eq + 1);
+  }
+  return args;
+}
+
+export function pickString() {
+  for (var i = 0; i < arguments.length; i++) {
+    var value = arguments[i];
+    if (typeof value !== "string") continue;
+    var trimmed = value.trim();
+    if (trimmed) return trimmed;
+  }
+  return undefined;
+}
+
+function configHome() {
+  var xdg = pickString(process.env.XDG_CONFIG_HOME);
+  return xdg ? xdg : join(homedir(), ".config");
+}
+
+function defaultStateDir() {
+  var configured = pickString(process.env.ORGX_WIZARD_CONFIG_HOME);
+  var root = configured ? configured : join(configHome(), "useorgx", "wizard");
+  return join(root, "sessions");
+}
+
+function defaultQueueDir() {
+  var configured = pickString(process.env.ORGX_WIZARD_CONFIG_HOME);
+  var root = configured ? configured : join(configHome(), "useorgx", "wizard");
+  return join(root, "session-summary-captures");
+}
+
+// Mirrors the backfill distiller so live and historical records agree on repo.
+export function repoOf(cwd) {
+  if (!cwd) return "unknown";
+  var marker = "/Code/";
+  var at = cwd.indexOf(marker);
+  if (at >= 0) {
+    var rest = cwd.slice(at + marker.length);
+    var slash = rest.indexOf("/");
+    var name = slash < 0 ? rest : rest.slice(0, slash);
+    if (name) return name;
+  }
+  return basename(cwd) || "unknown";
+}
+
+export function statePath(sessionId, dir) {
+  var root = dir ? dir : defaultStateDir();
+  // Session ids come from the harness; keep them filesystem-safe regardless.
+  var safe = String(sessionId).replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 128);
+  return join(root, safe + ".json");
+}
+
+function safeFilePart(value) {
+  return String(value).replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 128);
+}
+
+export function enqueueSummaryCapture(queueDir, summary, initiativeId, nowIso, captureKind) {
+  var root = queueDir ? queueDir : defaultQueueDir();
+  var stamp = String(nowIso).replace(/[^A-Za-z0-9]/g, "_");
+  var captureId = [summary.source_client, summary.session_id, summary.ended_at, summary.events].join(":");
+  var nonce = Date.now().toString(36) + "-" + Math.random().toString(36).slice(2, 10);
+  var name = "summary-" + safeFilePart(summary.source_client) + "-" + safeFilePart(summary.session_id) + "-" + stamp + "-" + process.pid + "-" + nonce + ".capture.json";
+  var target = join(root, name);
+  var temporary = target + ".tmp";
+  var capture = {
+    schema_version: "orgx-session-summary-capture/v1",
+    capture_id: captureId,
+    capture_kind: captureKind,
+    queued_at: nowIso,
+    session: summary,
+  };
+  if (initiativeId) capture.initiative_id = initiativeId;
+  try {
+    mkdirSync(root, { recursive: true, mode: 0o700 });
+    var descriptor = openSync(temporary, "w", 0o600);
+    try {
+      writeSync(descriptor, JSON.stringify(capture), undefined, "utf8");
+      fsyncSync(descriptor);
+    } finally {
+      closeSync(descriptor);
+    }
+    renameSync(temporary, target);
+    return { path: target, capture: capture };
+  } catch (e) {
+    try { rmSync(temporary, { force: true }); } catch (ignored) {}
+    return null;
+  }
+}
+
+export function emptyState(sessionId, sourceClient, cwd, nowIso) {
+  return {
+    session_id: sessionId,
+    source_client: sourceClient,
+    cwd: cwd === undefined ? null : cwd,
+    repo: repoOf(cwd),
+    first_ts: nowIso,
+    last_ts: nowIso,
+    events: 0,
+    prompts: 0,
+    tool_calls: 0,
+    tools: {},
+    edits: 0,
+    bash: 0,
+    action_seq: 0,
+    actions: [],
+    actions_omitted: 0,
+    pending_actions: [],
+    pending_starts_omitted: 0,
+    permission_requests: 0,
+    permission_modes: [],
+    work_context: null,
+  };
+}
+
+// One bounded read-modify-write. No spool, no network, no unbounded growth:
+// the tool map is capped so a pathological session cannot inflate the file.
+var MAX_TOOL_KEYS = 40;
+var MAX_CAPTURE_ACTIONS = 32;
+var MAX_PENDING_ACTIONS = 32;
+
+function isPromptEvent(event) {
+  return event === "UserPromptSubmit" || String(event).indexOf("user_prompt") >= 0;
+}
+
+function isToolCompletionEvent(event) {
+  var normalized = String(event).toLowerCase();
+  return event === "PostToolUse" ||
+    event === "PostToolUseFailure" ||
+    normalized.indexOf("post_tool_use") >= 0;
+}
+
+function ensureExecutionState(state) {
+  if (!Number.isFinite(state.action_seq)) state.action_seq = 0;
+  if (!Array.isArray(state.actions)) state.actions = [];
+  if (!Number.isFinite(state.actions_omitted)) state.actions_omitted = 0;
+  if (!Array.isArray(state.pending_actions)) state.pending_actions = [];
+  if (!Number.isFinite(state.pending_starts_omitted)) state.pending_starts_omitted = 0;
+  if (!Number.isFinite(state.permission_requests)) state.permission_requests = 0;
+  if (!Array.isArray(state.permission_modes)) state.permission_modes = [];
+  return state;
+}
+
+function nextActionId(state) {
+  state.action_seq += 1;
+  return "action-" + String(state.action_seq).padStart(6, "0");
+}
+
+function boundedString(value, max) {
+  var text = pickString(value);
+  return text ? text.slice(0, max) : undefined;
+}
+
+function safeDuration(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) return undefined;
+  return Math.min(Math.round(value), 86400000);
+}
+
+function actionResult(event, sourceClient) {
+  if (event === "PostToolUseFailure" || String(event).toLowerCase().indexOf("failure") >= 0) {
+    return "failed";
+  }
+  // Claude's PostToolUse contract fires only after success. Codex documents
+  // PostToolUse for completed tools, including non-zero Bash exits, so its
+  // outcome must remain explicitly unclassified without reading tool output.
+  return sourceClient === "claude-code" ? "succeeded" : "completed_unknown";
+}
+
+function pendingIndex(state, toolUseId) {
+  if (!toolUseId) return -1;
+  for (var i = 0; i < state.pending_actions.length; i++) {
+    if (state.pending_actions[i].correlation_key === toolUseId) return i;
+  }
+  return -1;
+}
+
+function observeAction(state, input) {
+  var event = input.event;
+  var toolName = boundedString(input.toolName, 120);
+  if (!toolName) return;
+  var toolUseId = boundedString(input.toolUseId, 200);
+
+  if (event === "PreToolUse" || String(event).toLowerCase().indexOf("pre_tool_use") >= 0) {
+    if (pendingIndex(state, toolUseId) >= 0) return;
+    if (state.pending_actions.length >= MAX_PENDING_ACTIONS) {
+      state.pending_starts_omitted += 1;
+      return;
+    }
+    state.pending_actions.push({
+      id: nextActionId(state),
+      correlation_key: toolUseId,
+      tool_name: normalizeToolName(toolName),
+      started_at: input.nowIso,
+      turn_id: boundedString(input.turnId, 120),
+    });
+    return;
+  }
+
+  if (!isToolCompletionEvent(event)) return;
+  var index = pendingIndex(state, toolUseId);
+  var pending = index >= 0 ? state.pending_actions.splice(index, 1)[0] : null;
+  if (!pending) state.pending_starts_omitted += 1;
+  var action = {
+    id: pending ? pending.id : nextActionId(state),
+    type: "tool.invoke",
+    tool_name: normalizeToolName(toolName),
+    status: actionResult(event, state.source_client),
+    started_at: pending ? pending.started_at : undefined,
+    completed_at: input.nowIso,
+    duration_ms: safeDuration(input.durationMs),
+    turn_id: boundedString(input.turnId, 120) || (pending ? pending.turn_id : undefined),
+    provenance: "runtime_observed",
+  };
+  if (state.actions.length < MAX_CAPTURE_ACTIONS) state.actions.push(action);
+  else state.actions_omitted += 1;
+}
+
+export function applyEvent(state, input) {
+  ensureExecutionState(state);
+  var event = input.event;
+  var toolName = input.toolName;
+  state.events += 1;
+  state.last_ts = input.nowIso;
+
+  if (isPromptEvent(event)) state.prompts += 1;
+
+  if (event === "PermissionRequest") state.permission_requests += 1;
+  var permissionMode = boundedString(input.permissionMode, 40);
+  if (
+    permissionMode &&
+    state.permission_modes.indexOf(permissionMode) < 0 &&
+    state.permission_modes.length < 8
+  ) {
+    state.permission_modes.push(permissionMode);
+  }
+
+  observeAction(state, input);
+
+  if (toolName && isToolCompletionEvent(event)) {
+    state.tool_calls += 1;
+    var known = state.tools[toolName] !== undefined;
+    if (known || Object.keys(state.tools).length < MAX_TOOL_KEYS) {
+      state.tools[toolName] = (state.tools[toolName] || 0) + 1;
+    }
+    if (toolName === "Write" || toolName === "Edit" || toolName === "NotebookEdit") state.edits += 1;
+    if (toolName === "Bash") state.bash += 1;
+  }
+  return state;
+}
+
+// Long MCP tool names ("mcp__<uuid>__<tool>") can make a raw tool map dominate
+// the payload, so keep the heaviest tools and bucket the tail. This bounds the
+// summary regardless of how varied or long a session gets.
+var MAX_REPORTED_TOOLS = 12;
+var MAX_TOOL_NAME = 48;
+
+// "mcp__c2ed4428-8c64-4586-9c2a-52eac05637b8__search-contacts" is mostly an
+// opaque server uuid. The tool suffix is the part with analytic value, so
+// collapse the uuid rather than truncating the informative end.
+export function normalizeToolName(name) {
+  var mcp = /^mcp__[0-9a-fA-F-]{16,}__(.+)$/.exec(name);
+  var base = mcp ? "mcp__" + mcp[1] : name;
+  return base.length > MAX_TOOL_NAME ? base.slice(0, MAX_TOOL_NAME) : base;
+}
+
+export function boundTools(tools) {
+  // Collapse first so two variants of the same tool merge before ranking.
+  var merged = {};
+  var names = Object.keys(tools);
+  for (var i = 0; i < names.length; i++) {
+    var key = normalizeToolName(names[i]);
+    merged[key] = (merged[key] || 0) + tools[names[i]];
+  }
+  var entries = Object.keys(merged).map(function (k) { return [k, merged[k]]; });
+  entries.sort(function (a, b) { return b[1] - a[1]; });
+  var out = {};
+  if (entries.length <= MAX_REPORTED_TOOLS) {
+    for (var j = 0; j < entries.length; j++) out[entries[j][0]] = entries[j][1];
+    return out;
+  }
+  for (var k = 0; k < MAX_REPORTED_TOOLS; k++) out[entries[k][0]] = entries[k][1];
+  var other = 0;
+  for (var m = MAX_REPORTED_TOOLS; m < entries.length; m++) other += entries[m][1];
+  out.__other__ = other;
+  out.__other_tools__ = entries.length - MAX_REPORTED_TOOLS;
+  return out;
+}
+
+function buildExecutionObservation(state, captureKind) {
+  ensureExecutionState(state);
+  var remaining = Math.max(0, MAX_CAPTURE_ACTIONS - state.actions.length);
+  var includedPending = state.pending_actions.slice(0, remaining).map(function (pending) {
+    return {
+      id: pending.id,
+      type: "tool.invoke",
+      tool_name: pending.tool_name,
+      status: "running",
+      started_at: pending.started_at,
+      turn_id: pending.turn_id,
+      provenance: "runtime_observed",
+    };
+  });
+  var pendingOmitted = Math.max(0, state.pending_actions.length - includedPending.length);
+  var actions = state.actions.concat(includedPending).map(function (action) {
+    var out = {
+      id: boundedString(action.id, 80),
+      type: "tool.invoke",
+      tool_name: boundedString(action.tool_name, 48),
+      status: action.status,
+      provenance: "runtime_observed",
+    };
+    if (action.started_at) out.started_at = action.started_at;
+    if (action.completed_at) out.completed_at = action.completed_at;
+    if (action.duration_ms !== undefined) out.duration_ms = action.duration_ms;
+    if (action.turn_id) out.turn_id = action.turn_id;
+    return out;
+  });
+  var omitted = state.actions_omitted + pendingOmitted;
+  var workContext = state.work_context && typeof state.work_context === "object"
+    ? state.work_context
+    : null;
+  var unavailable = ["verification"];
+  if (!workContext || !workContext.intent) unavailable.push("intent");
+  if (!workContext || !workContext.authority) unavailable.push("authority_decision");
+  if (!workContext || !workContext.cost) unavailable.push("cost");
+  if (!workContext || !Array.isArray(workContext.artifact_refs) || workContext.artifact_refs.length === 0) {
+    unavailable.push("artifact_refs");
+  }
+  return {
+    schema_version: "orgx-session-execution-observation/v1",
+    boundary: captureKind || "legacy_unspecified",
+    terminal_observed: captureKind === "session_end",
+    actions: actions,
+    actions_completed_observed: state.tool_calls,
+    actions_omitted: omitted,
+    start_times_omitted: state.pending_starts_omitted,
+    pending_actions: state.pending_actions.length,
+    permission_requests_observed: state.permission_requests,
+    permission_modes_observed: state.permission_modes.slice(0, 8),
+    action_capture_complete:
+      omitted === 0 &&
+      state.pending_starts_omitted === 0 &&
+      state.pending_actions.length === 0,
+    unavailable_fields: unavailable,
+  };
+}
+
+export function buildSummary(state, nowIso, captureKind) {
+  var first = Date.parse(state.first_ts);
+  var last = Date.parse(state.last_ts || nowIso);
+  var spanOk = isFinite(first) && isFinite(last);
+  var metadata = { execution: buildExecutionObservation(state, captureKind) };
+  if (state.work_context && typeof state.work_context === "object") {
+    metadata.work_context = state.work_context;
+  }
+  return {
+    schema_version: SCHEMA_VERSION,
+    source: "orgx_session_summary",
+    session_id: state.session_id,
+    source_client: state.source_client,
+    repo: state.repo,
+    cwd: state.cwd,
+    day: isFinite(first) ? new Date(first).toISOString().slice(0, 10) : "unknown",
+    started_at: state.first_ts,
+    ended_at: state.last_ts,
+    duration_min: spanOk ? Math.round((last - first) / 60000) : 0,
+    events: state.events,
+    prompts: state.prompts,
+    tool_calls: state.tool_calls,
+    tools: boundTools(state.tools),
+    edits: state.edits,
+    bash: state.bash,
+    metadata: metadata,
+  };
+}
+
+export function readState(path) {
+  try {
+    var parsed = JSON.parse(readFileSync(path, "utf8"));
+    var ok = parsed && typeof parsed === "object" && !Array.isArray(parsed);
+    return ok ? parsed : null;
+  } catch (e) {
+    return null;
+  }
+}
+
+export function writeState(path, state) {
+  try {
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    writeFileSync(path, JSON.stringify(state), { encoding: "utf8", mode: 0o600 });
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+async function readStdin() {
+  try {
+    var chunks = [];
+    for await (var chunk of process.stdin) chunks.push(Buffer.from(chunk));
+    return Buffer.concat(chunks).toString("utf8");
+  } catch (e) {
+    return "";
+  }
+}
+
+export function parseJson(value) {
+  try {
+    var parsed = JSON.parse(value || "{}");
+    var ok = parsed && typeof parsed === "object" && !Array.isArray(parsed);
+    return ok ? parsed : {};
+  } catch (e) {
+    return {};
+  }
+}
+
+function workString(value, max) {
+  if (typeof value !== "string") return null;
+  var trimmed = value.trim();
+  return trimmed && trimmed.length <= max ? trimmed : null;
+}
+
+function workObject(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+
+function workStrings(value, max) {
+  if (value === undefined) return [];
+  if (!Array.isArray(value) || value.length > 20) return null;
+  var output = [];
+  for (var i = 0; i < value.length; i++) {
+    var item = workString(value[i], max);
+    if (!item) return null;
+    if (output.indexOf(item) < 0) output.push(item);
+  }
+  return output;
+}
+
+function workRef(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  var system = workString(value.system, 120);
+  var type = workString(value.type, 120);
+  var id = workString(value.id, 500);
+  var uri = value.uri === undefined ? undefined : workString(value.uri, 1000);
+  var version = value.version === undefined ? undefined : workString(value.version, 120);
+  if (!system || !type || !id || uri === null || version === null) return null;
+  if (uri && /[\0- ]/.test(uri)) return null;
+  var ref = { system: system, type: type, id: id };
+  if (uri) ref.uri = uri;
+  if (version) ref.version = version;
+  return ref;
+}
+
+function workRefs(value) {
+  if (value === undefined) return [];
+  if (!Array.isArray(value) || value.length > 20) return null;
+  var refs = [];
+  var seen = {};
+  for (var i = 0; i < value.length; i++) {
+    var ref = workRef(value[i]);
+    if (!ref) return null;
+    var key = ref.system + "\0" + ref.type + "\0" + ref.id;
+    if (!seen[key]) {
+      seen[key] = true;
+      refs.push(ref);
+    }
+  }
+  refs.sort(function (a, b) {
+    var left = a.system + "\0" + a.type + "\0" + a.id;
+    var right = b.system + "\0" + b.type + "\0" + b.id;
+    return left < right ? -1 : left > right ? 1 : 0;
+  });
+  return refs;
+}
+
+function workIso(value) {
+  var text = workString(value, 100);
+  return text && /^d{4}-d{2}-d{2}Td{2}:d{2}:d{2}(?:.d+)?(?:Z|[+-]d{2}:d{2})$/.test(text) && !Number.isNaN(Date.parse(text))
+    ? text
+    : null;
+}
+
+export function parseExplicitWorkContext(value) {
+  if (!value || Buffer.byteLength(String(value), "utf8") > 4096) return null;
+  var parsed = parseJson(value);
+  if (parsed.schema_version !== "orgx-session-work-context/v1") return null;
+  var intent = workObject(parsed.intent);
+  var authority = workObject(parsed.authority);
+  var scope = workObject(authority && authority.scope);
+  var cost = workObject(parsed.cost);
+  if (!intent || !authority || !scope || !cost) return null;
+  var summary = workString(intent.summary, 2000);
+  var objective = intent.objective === undefined ? undefined : workString(intent.objective, 4000);
+  var acceptance = workStrings(intent.acceptance_criteria, 1000);
+  var intentConstraints = workStrings(intent.constraints, 1000);
+  var requestRef = intent.request_ref === undefined ? undefined : workRef(intent.request_ref);
+  var modes = ["explicit", "delegated", "inherited", "policy", "none", "unknown"];
+  var statuses = ["granted", "restricted", "denied", "expired", "unknown"];
+  var mode = workString(authority.mode, 40);
+  var status = workString(authority.status, 40);
+  var actions = workStrings(scope.actions, 120);
+  var resources = workRefs(scope.resources);
+  var systems = workStrings(scope.systems, 120);
+  var spend = scope.spend_limit === undefined ? undefined : workObject(scope.spend_limit);
+  var spendCurrency = spend === undefined ? undefined : workString(spend && spend.currency, 12);
+  var spendAmount = spend && spend.amount;
+  var authorityConstraints = workStrings(authority.constraints, 1000);
+  var authorizationRef = authority.authorization_ref === undefined ? undefined : workRef(authority.authorization_ref);
+  var validFrom = authority.valid_from === undefined ? undefined : workIso(authority.valid_from);
+  var validUntil = authority.valid_until === undefined ? undefined : workIso(authority.valid_until);
+  var artifactRefs = workRefs(parsed.artifact_refs);
+  var evidenceRefs = workRefs(parsed.evidence_refs);
+  var currency = workString(cost.currency, 12);
+  var source = cost.source === undefined ? undefined : workString(cost.source, 120);
+  if (!summary || objective === null || acceptance === null || intentConstraints === null || requestRef === null) return null;
+  if (!mode || modes.indexOf(mode) < 0 || !status || statuses.indexOf(status) < 0) return null;
+  if (actions === null || resources === null || systems === null || authorityConstraints === null || authorizationRef === null) return null;
+  if (spend !== undefined && (!spend || !spendCurrency || !/^[A-Z][A-Z0-9_-]{1,11}$/.test(spendCurrency) || typeof spendAmount !== "number" || !Number.isFinite(spendAmount) || spendAmount < 0 || spendAmount > 100000)) return null;
+  if (validFrom === null || validUntil === null || (validFrom && validUntil && Date.parse(validUntil) < Date.parse(validFrom))) return null;
+  if (!currency || !/^[A-Z][A-Z0-9_-]{1,11}$/.test(currency) || typeof cost.total !== "number" || !Number.isFinite(cost.total) || cost.total < 0 || cost.total > 100000 || source === null) return null;
+  if (cost.estimated !== undefined && typeof cost.estimated !== "boolean") return null;
+  if (artifactRefs === null || evidenceRefs === null) return null;
+  var normalizedIntent = { summary: summary, acceptance_criteria: acceptance, constraints: intentConstraints };
+  if (objective) normalizedIntent.objective = objective;
+  if (requestRef) normalizedIntent.request_ref = requestRef;
+  var normalizedAuthority = {
+    mode: mode,
+    status: status,
+    scope: { actions: actions, resources: resources, systems: systems },
+    constraints: authorityConstraints,
+  };
+  if (spend !== undefined) normalizedAuthority.scope.spend_limit = { currency: spendCurrency, amount: spendAmount };
+  if (authorizationRef) normalizedAuthority.authorization_ref = authorizationRef;
+  if (validFrom) normalizedAuthority.valid_from = validFrom;
+  if (validUntil) normalizedAuthority.valid_until = validUntil;
+  var normalizedCost = { currency: currency, total: cost.total, estimated: cost.estimated !== false };
+  if (source) normalizedCost.source = source;
+  return {
+    schema_version: "orgx-session-work-context/v1",
+    provenance: "producer_asserted",
+    intent: normalizedIntent,
+    authority: normalizedAuthority,
+    cost: normalizedCost,
+    artifact_refs: artifactRefs,
+    evidence_refs: evidenceRefs,
+  };
+}
+
+function autoFlushDisabled(value) {
+  var normalized = String(value || "").trim().toLowerCase();
+  return normalized === "off" || normalized === "false" || normalized === "0";
+}
+
+/**
+ * Ask a detached Wizard process to deliver the durable queue. The hook itself
+ * performs no network or credential work and never waits for delivery.
+ */
+export function triggerQueueDelivery(args, env, queueDir, spawnImpl) {
+  if (autoFlushDisabled(env.ORGX_SESSION_SUMMARY_AUTO_FLUSH)) return false;
+  var nodePath = pickString(args.delivery_node);
+  var cliPath = pickString(args.delivery_cli);
+  if (!nodePath || !cliPath || !queueDir) return false;
+  var configuredLimit = parseInt(
+    pickString(args.auto_flush_limit, env.ORGX_SESSION_SUMMARY_AUTO_FLUSH_LIMIT) || "",
+    10
+  );
+  var limit = Number.isFinite(configuredLimit)
+    ? Math.max(1, Math.min(configuredLimit, 100))
+    : 25;
+  try {
+    var child = spawnImpl(
+      nodePath,
+      [
+        cliPath,
+        "hooks",
+        "flush",
+        "--background",
+        "--limit=" + String(limit),
+        "--queue=" + queueDir,
+      ],
+      { detached: true, stdio: "ignore" }
+    );
+    if (child && typeof child.on === "function") {
+      child.on("error", function () {});
+    }
+    if (child && typeof child.unref === "function") child.unref();
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+export async function main(options) {
+  var opts = options || {};
+  var argv = opts.argv ? opts.argv : process.argv.slice(2);
+  var env = opts.env ? opts.env : process.env;
+  var stdinText = opts.stdinText === undefined ? "" : opts.stdinText;
+  var now = opts.now ? opts.now : function () { return new Date().toISOString(); };
+  var dir = opts.dir;
+  var spawnImpl = opts.spawnImpl ? opts.spawnImpl : spawn;
+
+  var args = parseArgs(argv);
+  var payload = parseJson(stdinText);
+  var nowIso = now();
+  var explicitWorkContext = parseExplicitWorkContext(env.ORGX_SESSION_WORK_CONTEXT);
+
+  var event = pickString(args.event, payload.hook_event_name, payload.hookEventName, "unknown");
+  var sessionId = pickString(payload.session_id, payload.sessionId, args.session_id);
+  if (!sessionId) return { ok: true, skipped: "missing_session_id" };
+
+  var sourceClient = pickString(args.source_client, env.ORGX_SOURCE_CLIENT, "claude-code");
+  var cwd = pickString(payload.cwd, args.cwd);
+  var stateDir = dir ? dir : pickString(args.state_dir, env.ORGX_SESSION_STATE_DIR);
+  var path = statePath(sessionId, stateDir);
+
+  var terminal = event === "Stop" || event === "SessionEnd";
+
+  if (!terminal) {
+    // Hot path: one small file read + write. Never a network call.
+    var existing = readState(path);
+    var state = existing ? existing : emptyState(sessionId, sourceClient, cwd, nowIso);
+    if (!state.cwd && cwd) {
+      state.cwd = cwd;
+      state.repo = repoOf(cwd);
+    }
+    if (explicitWorkContext) state.work_context = explicitWorkContext;
+    var toolName = pickString(
+      payload.tool_name,
+      payload.toolName,
+      payload.tool ? payload.tool.name : undefined
+    );
+    applyEvent(state, {
+      event: event,
+      toolName: toolName,
+      toolUseId: pickString(payload.tool_use_id, payload.toolUseId),
+      turnId: pickString(payload.turn_id, payload.turnId),
+      durationMs: payload.duration_ms,
+      permissionMode: pickString(payload.permission_mode, payload.permissionMode),
+      nowIso: nowIso,
+    });
+    writeState(path, state);
+    return { ok: true, counted: true, event: event };
+  }
+
+  // Terminal: persist one cumulative snapshot, then ask a detached Wizard
+  // worker to flush. The hook never owns credentials, retries, or network I/O.
+  var finalState = readState(path);
+  if (!finalState) return { ok: true, skipped: "no_session_state" };
+  if (explicitWorkContext) finalState.work_context = explicitWorkContext;
+  var initiativeId = pickString(env.ORGX_INITIATIVE_ID, args.initiative);
+  var queueDir = pickString(args.queue_dir, env.ORGX_SESSION_SUMMARY_QUEUE_DIR) || defaultQueueDir();
+  var captureKind = event === "SessionEnd" ? "session_end" : "turn_boundary";
+  var summary = buildSummary(finalState, nowIso, captureKind);
+  var queued = enqueueSummaryCapture(queueDir, summary, initiativeId, nowIso, captureKind);
+  if (!queued) return { ok: true, skipped: "queue_write_failed", summary: summary };
+  var deliveryTriggered = triggerQueueDelivery(args, env, queueDir, spawnImpl);
+
+  if (event === "SessionEnd") {
+    try {
+      rmSync(path, { force: true });
+    } catch (e) {
+      // keep going
+    }
+  }
+
+  return {
+    ok: true,
+    queued: true,
+    queue_path: queued.path,
+    delivery_triggered: deliveryTriggered,
+    final: event === "SessionEnd",
+    summary: summary,
+  };
+}
+
+var invokedDirectly = process.argv[1] && import.meta.url === "file://" + process.argv[1];
+if (invokedDirectly) {
+  readStdin()
+    .then(function (text) { return main({ stdinText: text }); })
+    .catch(function () {})
+    .finally(function () { process.exit(0); });
+}
+`;
+}
+
+// src/lib/runtime-hooks.ts
 var HOOK_MARKER = "orgx-session-hook.mjs";
 var EMIT_HOOK_MARKER = "orgx-emit-execution-graph.mjs";
-var HOOK_EVENTS = ["SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "PermissionRequest", "Stop"];
-var CLAUDE_HOOK_EVENTS = ["SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "SubagentStop", "Stop", "SessionEnd"];
+var SUMMARY_HOOK_MARKER = SESSION_SUMMARY_HOOK_MARKER;
+var HOOK_EVENTS = [
+  "SessionStart",
+  "UserPromptSubmit",
+  "PreToolUse",
+  "PostToolUse",
+  "PermissionRequest",
+  "Stop",
+  "SessionEnd"
+];
+var CLAUDE_HOOK_EVENTS = [
+  "SessionStart",
+  "UserPromptSubmit",
+  "PreToolUse",
+  "PostToolUse",
+  "PostToolUseFailure",
+  "PermissionRequest",
+  "SubagentStop",
+  "Stop",
+  "SessionEnd"
+];
+function currentPackagedCliPath() {
+  if (!process.argv[1]) return "";
+  const candidate = resolve2(process.argv[1]);
+  return /\.(?:cts|mts|ts|tsx)$/i.test(candidate) ? "" : candidate;
+}
 function defaultPaths(options = {}) {
   const hookDir = join8(ORGX_WIZARD_CONFIG_HOME, "hooks");
   return {
@@ -13638,6 +14386,11 @@ function defaultPaths(options = {}) {
     codexHooksPath: options.codexHooksPath ?? join8(CODEX_DIR, "hooks.json"),
     hookScriptPath: options.hookScriptPath ?? join8(hookDir, HOOK_MARKER),
     emitHookScriptPath: options.emitHookScriptPath ?? join8(hookDir, EMIT_HOOK_MARKER),
+    summaryHookScriptPath: options.summaryHookScriptPath ?? join8(hookDir, SUMMARY_HOOK_MARKER),
+    sessionStateDir: options.sessionStateDir ?? join8(ORGX_WIZARD_CONFIG_HOME, "sessions"),
+    sessionSummaryQueueDir: options.sessionSummaryQueueDir ?? join8(ORGX_WIZARD_CONFIG_HOME, "session-summary-captures"),
+    deliveryNodePath: options.deliveryNodePath ?? process.execPath,
+    deliveryCliPath: options.deliveryCliPath ?? currentPackagedCliPath(),
     outboxPath: options.outboxPath ?? join8(hookDir, "events.jsonl")
   };
 }
@@ -13646,6 +14399,13 @@ function countJsonlLines(path) {
   if (!raw) return 0;
   return raw.split(/\r?\n/).filter((line) => line.trim().length > 0).length;
 }
+function countSessionSummaryCaptures(path) {
+  try {
+    return readdirSync6(path).filter((name) => name.endsWith(".capture.json")).length;
+  } catch {
+    return 0;
+  }
+}
 function backupPath(path, now) {
   const timestamp = now.toISOString().replace(/[:.]/g, "-");
   return `${path}.bak.${timestamp}`;
@@ -13667,10 +14427,29 @@ function codexHasNotify(raw) {
 }
 function buildRuntimeHookScriptContent() {
   return `#!/usr/bin/env node
-import { appendFileSync, mkdirSync } from "node:fs";
+import { appendFileSync, mkdirSync, renameSync, statSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { homedir } from "node:os";
 
+const MAX_OUTBOX_BYTES = ${HOOK_OUTBOX_MAX_BYTES};
+
+function outboxLimit() {
+  const raw = parseInt(process.env.ORGX_WIZARD_HOOK_OUTBOX_MAX_BYTES || "", 10);
+  return Number.isFinite(raw) && raw > 0 ? raw : MAX_OUTBOX_BYTES;
+}
+
+function spoolDisabled() {
+  return String(process.env.ORGX_WIZARD_HOOK_SPOOL || "").trim().toLowerCase() === "off";
+}
+
+function rotateIfOversized(path) {
+  try {
+    if (statSync(path).size > outboxLimit()) renameSync(path, path + ".1");
+  } catch (error) {
+    // No spool yet, or rotation is not possible. Either way, keep going.
+  }
+}
+
 function parseArgs(argv) {
   const args = {};
   for (const arg of argv) {
@@ -13740,8 +14519,11 @@ const record = {
 };
 
 try {
-  mkdirSync(dirname(outbox), { recursive: true, mode: 0o700 });
-  appendFileSync(outbox, JSON.stringify(record) + "\\n", { encoding: "utf8", mode: 0o600 });
+  if (!spoolDisabled()) {
+    mkdirSync(dirname(outbox), { recursive: true, mode: 0o700 });
+    rotateIfOversized(outbox);
+    appendFileSync(outbox, JSON.stringify(record) + "\\n", { encoding: "utf8", mode: 0o600 });
+  }
 } catch {
   // Hooks must never break the user's agent runtime.
 }
@@ -13840,7 +14622,7 @@ function authHeaders(env) {
   try {
     const args = parseArgs(process.argv.slice(2));
     const env = process.env;
-    if (!(truthy(args.enabled) || truthy(env.ORGX_EMIT_EXECUTION_GRAPH))) return;
+    if (!truthy(env.ORGX_EMIT_EXECUTION_GRAPH)) return;
     const initiative = pick(env.ORGX_INITIATIVE_ID, args.initiative);
     if (!initiative) return;
     const auth = authHeaders(env);
@@ -13872,7 +14654,7 @@ function authHeaders(env) {
     const ctrl = new AbortController();
     const timer = setTimeout(() => ctrl.abort(), parseInt(env.ORGX_EMIT_TIMEOUT_MS || "", 10) || 4000);
     try {
-      await fetch(base + "/api/client/live/execution-graph", {
+      await fetch(base + "/api/v1/live/execution-graph", {
         method: "POST",
         headers: Object.assign({ "Content-Type": "application/json" }, auth),
         body: JSON.stringify(event),
@@ -13888,10 +14670,69 @@ function buildEmitHookCommand(params) {
   return [
     "node",
     JSON.stringify(params.emitHookScriptPath),
-    "--enabled=true",
     `--source_client=${params.sourceClient}`
   ].join(" ");
 }
+function buildSummaryHookCommand(params) {
+  const terminal = params.event === "Stop" || params.event === "SessionEnd";
+  return [
+    "node",
+    JSON.stringify(params.summaryHookScriptPath),
+    `--event=${params.event}`,
+    `--source_client=${params.sourceClient}`,
+    `--state_dir=${JSON.stringify(params.sessionStateDir)}`,
+    `--queue_dir=${JSON.stringify(params.sessionSummaryQueueDir)}`,
+    ...terminal && params.deliveryNodePath && params.deliveryCliPath ? [
+      `--delivery_node=${JSON.stringify(params.deliveryNodePath)}`,
+      `--delivery_cli=${JSON.stringify(params.deliveryCliPath)}`
+    ] : []
+  ].join(" ");
+}
+function ensureClaudeSummaryHook(rules, event, paths) {
+  let changed = false;
+  let universal = rules.find((entry) => isRecord(entry) && entry.matcher === "");
+  if (!universal) {
+    universal = { matcher: "", hooks: [] };
+    rules.push(universal);
+    changed = true;
+  }
+  const desiredCommand = buildSummaryHookCommand({
+    deliveryCliPath: paths.deliveryCliPath,
+    deliveryNodePath: paths.deliveryNodePath,
+    event,
+    sessionStateDir: paths.sessionStateDir,
+    sessionSummaryQueueDir: paths.sessionSummaryQueueDir,
+    sourceClient: "claude-code",
+    summaryHookScriptPath: paths.summaryHookScriptPath
+  });
+  let desiredKept = false;
+  for (const rule of rules) {
+    if (!isRecord(rule)) continue;
+    const hooks = Array.isArray(rule.hooks) ? rule.hooks : [];
+    const next = [];
+    for (const hook of hooks) {
+      const isSummary = isRecord(hook) && typeof hook.command === "string" && hook.command.includes(SUMMARY_HOOK_MARKER);
+      if (!isSummary) {
+        next.push(hook);
+        continue;
+      }
+      if (rule === universal && hook.type === "command" && hook.command === desiredCommand && !desiredKept) {
+        next.push(hook);
+        desiredKept = true;
+      } else {
+        changed = true;
+      }
+    }
+    if (next.length !== hooks.length) rule.hooks = next;
+  }
+  if (!desiredKept) {
+    const hooks = Array.isArray(universal.hooks) ? universal.hooks : [];
+    hooks.push({ type: "command", command: desiredCommand });
+    universal.hooks = hooks;
+    changed = true;
+  }
+  return changed;
+}
 function mergeCodexHooks(raw, paths) {
   const value = parseJsonObject(raw);
   const hooks = isRecord(value.hooks) ? value.hooks : {};
@@ -13907,10 +14748,31 @@ function mergeCodexHooks(raw, paths) {
     const already = existing.some(
       (entry) => isRecord(entry) && typeof entry.command === "string" && entry.command.includes(HOOK_MARKER)
     );
-    if (!already) {
-      hooks[event] = [...existing, { command }];
+    const next = already ? [...existing] : [...existing, { command }];
+    if (!already) changed = true;
+    const desiredSummaryCommand = buildSummaryHookCommand({
+      deliveryCliPath: paths.deliveryCliPath,
+      deliveryNodePath: paths.deliveryNodePath,
+      event,
+      sessionStateDir: paths.sessionStateDir,
+      sessionSummaryQueueDir: paths.sessionSummaryQueueDir,
+      sourceClient: "codex",
+      summaryHookScriptPath: paths.summaryHookScriptPath
+    });
+    const summaryEntries = next.filter(
+      (entry) => isRecord(entry) && typeof entry.command === "string" && entry.command.includes(SUMMARY_HOOK_MARKER)
+    );
+    const summaryCurrent = summaryEntries.length === 1 && isRecord(summaryEntries[0]) && summaryEntries[0].command === desiredSummaryCommand;
+    if (!summaryCurrent) {
+      const withoutStaleSummary = next.filter(
+        (entry) => !(isRecord(entry) && typeof entry.command === "string" && entry.command.includes(SUMMARY_HOOK_MARKER))
+      );
+      withoutStaleSummary.push({ command: desiredSummaryCommand });
+      hooks[event] = withoutStaleSummary;
       changed = true;
+      continue;
     }
+    hooks[event] = next;
   }
   value.hooks = hooks;
   return { changed: changed || !raw, value };
@@ -13921,7 +14783,7 @@ function mergeClaudeHooks(raw, paths) {
   let changed = false;
   for (const event of CLAUDE_HOOK_EVENTS) {
     const list = Array.isArray(hooksRoot[event]) ? hooksRoot[event] : [];
-    const matcher = event === "PreToolUse" || event === "PostToolUse" ? "Bash|Write|Edit|MultiEdit|mcp__.*" : "";
+    const matcher = event === "PreToolUse" || event === "PostToolUse" || event === "PostToolUseFailure" ? "Bash|Write|Edit|MultiEdit|mcp__.*" : "";
     const command = buildHookCommand({
       event,
       hookScriptPath: paths.hookScriptPath,
@@ -13934,7 +14796,7 @@ function mergeClaudeHooks(raw, paths) {
       list.push(rule);
       changed = true;
     }
-    const hooks = Array.isArray(rule.hooks) ? rule.hooks : [];
+    let hooks = Array.isArray(rule.hooks) ? rule.hooks : [];
     const already = hooks.some(
       (entry) => isRecord(entry) && entry.type === "command" && typeof entry.command === "string" && entry.command.includes(HOOK_MARKER)
     );
@@ -13943,6 +14805,10 @@ function mergeClaudeHooks(raw, paths) {
       rule.hooks = hooks;
       changed = true;
     }
+    if (ensureClaudeSummaryHook(list, event, paths)) {
+      changed = true;
+    }
+    hooks = Array.isArray(rule.hooks) ? rule.hooks : [];
     if (event === "Stop") {
       const emitCommand = buildEmitHookCommand({
         emitHookScriptPath: paths.emitHookScriptPath,
@@ -13992,13 +14858,18 @@ function inspectRuntimeHooks(options = {}) {
   const codexConfigRaw = readTextIfExists(paths.codexConfigPath);
   const codexHooksRaw = readTextIfExists(paths.codexHooksPath);
   const claudeSettingsRaw = readTextIfExists(paths.claudeSettingsPath);
+  const hasAutomaticDelivery = (raw) => Boolean(
+    raw && raw.includes("--delivery_node=") && raw.includes("--delivery_cli=") && raw.includes(paths.deliveryNodePath) && raw.includes(paths.deliveryCliPath) && existsSync9(paths.deliveryNodePath) && existsSync9(paths.deliveryCliPath)
+  );
   return {
     paths,
     installed: {
       claudeCode: hasOrgxHook(claudeSettingsRaw),
       codex: hasOrgxHook(codexHooksRaw),
       hookScript: existsSync9(paths.hookScriptPath),
-      emitHookScript: existsSync9(paths.emitHookScriptPath)
+      emitHookScript: existsSync9(paths.emitHookScriptPath),
+      summaryHookScript: existsSync9(paths.summaryHookScriptPath),
+      automaticDelivery: hasAutomaticDelivery(codexHooksRaw) || hasAutomaticDelivery(claudeSettingsRaw)
     },
     codex: {
       configExists: Boolean(codexConfigRaw),
@@ -14006,7 +14877,8 @@ function inspectRuntimeHooks(options = {}) {
       hasNotify: codexHasNotify(codexConfigRaw),
       notifyPreserved: !codexHasNotify(codexConfigRaw) || !hasOrgxHook(codexConfigRaw)
     },
-    outboxEvents: countJsonlLines(paths.outboxPath)
+    outboxEvents: countJsonlLines(paths.outboxPath),
+    sessionSummaryCaptures: countSessionSummaryCaptures(paths.sessionSummaryQueueDir)
   };
 }
 function installRuntimeHooks(targets, options = {}) {
@@ -14018,7 +14890,8 @@ function installRuntimeHooks(targets, options = {}) {
     codex: false,
     codexConfig: false,
     hookScript: false,
-    emitHookScript: false
+    emitHookScript: false,
+    summaryHookScript: false
   };
   mkdirSync4(dirname5(paths.hookScriptPath), { recursive: true, mode: 448 });
   const scriptContent = buildRuntimeHookScriptContent();
@@ -14036,6 +14909,16 @@ function installRuntimeHooks(targets, options = {}) {
     writeTextFile(paths.emitHookScriptPath, emitScriptContent, { mode: 448 });
     changed.emitHookScript = true;
   }
+  mkdirSync4(dirname5(paths.summaryHookScriptPath), { recursive: true, mode: 448 });
+  const summaryScriptContent = buildSessionSummaryHookScriptContent();
+  if (readTextIfExists(paths.summaryHookScriptPath) !== summaryScriptContent) {
+    const backup = backupExisting(paths.summaryHookScriptPath, now);
+    if (backup) backups.push(backup);
+    writeTextFile(paths.summaryHookScriptPath, summaryScriptContent, { mode: 448 });
+    changed.summaryHookScript = true;
+  }
+  mkdirSync4(paths.sessionStateDir, { recursive: true, mode: 448 });
+  mkdirSync4(paths.sessionSummaryQueueDir, { recursive: true, mode: 448 });
   if (targets.includes("codex")) {
     const rawConfig = readTextIfExists(paths.codexConfigPath);
     const nextConfig = ensureCodexHooksFeature(rawConfig);
@@ -14085,6 +14968,679 @@ function parseRuntimeHookTargets(value) {
   return [...new Set(normalized)];
 }
 
+// src/lib/session-summary-queue.ts
+import { existsSync as existsSync10, readdirSync as readdirSync7, readFileSync as readFileSync8, unlinkSync as unlinkSync2 } from "fs";
+import { join as join9 } from "path";
+
+// src/lib/session-summary-backfill.ts
+import { createReadStream, renameSync as renameSync2, statSync as statSync5, writeFileSync as writeFileSync4 } from "fs";
+import { basename as basename5 } from "path";
+import { createInterface } from "readline";
+
+// src/lib/session-work-context.ts
+import { z } from "zod";
+var SESSION_WORK_CONTEXT_VERSION = "orgx-session-work-context/v1";
+var SESSION_WORK_CONTEXT_MAX_JSON_BYTES = 4 * 1024;
+var boundedText = (max) => z.string().trim().min(1).max(max);
+var currency = boundedText(12).regex(/^[A-Z][A-Z0-9_-]{1,11}$/);
+var externalReferenceSchema = z.object({
+  system: boundedText(120),
+  type: boundedText(120),
+  id: boundedText(500),
+  uri: boundedText(1e3).refine((value) => !/[\u0000-\u0020]/.test(value)).optional(),
+  version: boundedText(120).optional()
+});
+var stringList = (max) => z.array(boundedText(max)).max(20).default([]).transform((values) => [
+  ...new Set(values)
+]);
+var referenceList = z.array(externalReferenceSchema).max(20).default([]).transform((refs) => {
+  const unique = /* @__PURE__ */ new Map();
+  for (const ref of refs) {
+    unique.set(`${ref.system}\0${ref.type}\0${ref.id}`, ref);
+  }
+  return [...unique.values()].sort((left, right) => {
+    const a = `${left.system}\0${left.type}\0${left.id}`;
+    const b = `${right.system}\0${right.type}\0${right.id}`;
+    return a < b ? -1 : a > b ? 1 : 0;
+  });
+});
+var authoritySchema = z.object({
+  mode: z.enum([
+    "explicit",
+    "delegated",
+    "inherited",
+    "policy",
+    "none",
+    "unknown"
+  ]),
+  status: z.enum(["granted", "restricted", "denied", "expired", "unknown"]),
+  scope: z.object({
+    actions: stringList(120),
+    resources: referenceList,
+    systems: stringList(120),
+    spend_limit: z.object({
+      currency,
+      amount: z.number().finite().min(0).max(1e5)
+    }).optional()
+  }),
+  authorization_ref: externalReferenceSchema.optional(),
+  constraints: stringList(1e3),
+  valid_from: z.string().datetime({ offset: true }).optional(),
+  valid_until: z.string().datetime({ offset: true }).optional()
+}).refine(
+  (value) => !value.valid_from || !value.valid_until || Date.parse(value.valid_until) >= Date.parse(value.valid_from),
+  { message: "valid_until must not precede valid_from" }
+);
+var sessionWorkContextInputSchema = z.object({
+  schema_version: z.literal(SESSION_WORK_CONTEXT_VERSION),
+  intent: z.object({
+    summary: boundedText(2e3),
+    objective: boundedText(4e3).optional(),
+    acceptance_criteria: stringList(1e3),
+    constraints: stringList(1e3),
+    request_ref: externalReferenceSchema.optional()
+  }),
+  authority: authoritySchema,
+  cost: z.object({
+    currency,
+    total: z.number().finite().min(0).max(1e5),
+    estimated: z.boolean().default(true),
+    source: boundedText(120).optional()
+  }),
+  artifact_refs: referenceList,
+  evidence_refs: referenceList
+});
+function normalizeSessionWorkContext(value) {
+  const parsed = sessionWorkContextInputSchema.safeParse(value);
+  return parsed.success ? { ...parsed.data, provenance: "producer_asserted" } : null;
+}
+
+// src/lib/session-summary-backfill.ts
+var SESSION_EXECUTION_OBSERVATION_VERSION = "orgx-session-execution-observation/v1";
+var SESSION_EXECUTION_MAX_ACTIONS = 32;
+var SESSION_EXECUTION_UNAVAILABLE_FIELDS = /* @__PURE__ */ new Set([
+  "intent",
+  "authority_decision",
+  "artifact_refs",
+  "cost",
+  "verification"
+]);
+var SESSION_EXECUTION_PERMISSION_MODES = /* @__PURE__ */ new Set([
+  "default",
+  "acceptEdits",
+  "plan",
+  "dontAsk",
+  "bypassPermissions"
+]);
+function isRecord3(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function boundedString(value, maxLength) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed ? trimmed.slice(0, maxLength) : void 0;
+}
+function boundedCount(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? Math.min(value, 1e7) : 0;
+}
+function validTimestamp(value) {
+  const text2 = boundedString(value, 100);
+  return text2 && !Number.isNaN(Date.parse(text2)) ? text2 : void 0;
+}
+function normalizeObservedAction(value) {
+  if (!isRecord3(value)) return null;
+  const id = boundedString(value.id, 80);
+  const toolName = boundedString(value.tool_name, 48);
+  const status = boundedString(value.status, 40);
+  if (!id || !toolName || !status || !["running", "succeeded", "failed", "completed_unknown"].includes(status)) {
+    return null;
+  }
+  const startedAt = validTimestamp(value.started_at);
+  const completedAt = validTimestamp(value.completed_at);
+  const durationMs = typeof value.duration_ms === "number" && Number.isInteger(value.duration_ms) && value.duration_ms >= 0 ? Math.min(value.duration_ms, 864e5) : void 0;
+  const turnId = boundedString(value.turn_id, 120);
+  return {
+    id,
+    type: "tool.invoke",
+    tool_name: toolName,
+    status,
+    provenance: "runtime_observed",
+    ...startedAt ? { started_at: startedAt } : {},
+    ...completedAt ? { completed_at: completedAt } : {},
+    ...durationMs !== void 0 ? { duration_ms: durationMs } : {},
+    ...turnId ? { turn_id: turnId } : {}
+  };
+}
+function normalizeSessionExecutionObservation(value) {
+  if (!isRecord3(value) || value.schema_version !== SESSION_EXECUTION_OBSERVATION_VERSION) {
+    return null;
+  }
+  const boundary = boundedString(value.boundary, 40);
+  if (!boundary || ![
+    "turn_boundary",
+    "session_end",
+    "historical_backfill",
+    "legacy_unspecified"
+  ].includes(boundary)) {
+    return null;
+  }
+  const actions = (Array.isArray(value.actions) ? value.actions : []).slice(0, SESSION_EXECUTION_MAX_ACTIONS).map(normalizeObservedAction).filter((action) => action !== null);
+  const unavailableFields = (Array.isArray(value.unavailable_fields) ? value.unavailable_fields : []).filter(
+    (field) => typeof field === "string" && SESSION_EXECUTION_UNAVAILABLE_FIELDS.has(field)
+  );
+  const permissionModes = (Array.isArray(value.permission_modes_observed) ? value.permission_modes_observed : []).filter(
+    (mode) => typeof mode === "string" && SESSION_EXECUTION_PERMISSION_MODES.has(mode)
+  );
+  return {
+    schema_version: SESSION_EXECUTION_OBSERVATION_VERSION,
+    boundary,
+    terminal_observed: value.terminal_observed === true,
+    actions,
+    actions_completed_observed: boundedCount(value.actions_completed_observed),
+    actions_omitted: boundedCount(value.actions_omitted),
+    start_times_omitted: boundedCount(value.start_times_omitted),
+    pending_actions: boundedCount(value.pending_actions),
+    permission_requests_observed: boundedCount(value.permission_requests_observed),
+    permission_modes_observed: [...new Set(permissionModes)].slice(0, 8),
+    action_capture_complete: value.action_capture_complete === true,
+    unavailable_fields: [...new Set(unavailableFields)]
+  };
+}
+function buildMinimalCloudSummary(summary, metadata) {
+  const execution = normalizeSessionExecutionObservation(summary.metadata?.execution);
+  const workContext = normalizeSessionWorkContext(summary.metadata?.work_context);
+  const { cwd: _localOnlyCwd, metadata: _localOnlyMetadata, ...minimal } = summary;
+  return {
+    ...minimal,
+    metadata: {
+      capture: {
+        ...metadata.captureId ? { id: metadata.captureId } : {},
+        kind: metadata.captureKind,
+        ...metadata.queuedAt ? { queued_at: metadata.queuedAt } : {}
+      },
+      privacy: {
+        profile: "minimal",
+        raw_content_included: false,
+        cwd_included: false
+      },
+      ...execution ? { execution } : {},
+      ...workContext ? { work_context: workContext } : {}
+    }
+  };
+}
+var MAX_REPORTED_TOOLS = 12;
+var MAX_TOOL_NAME = 48;
+function repoOf(cwd) {
+  if (!cwd) return "unknown";
+  const marker = "/Code/";
+  const at = cwd.indexOf(marker);
+  if (at >= 0) {
+    const rest = cwd.slice(at + marker.length);
+    const slash = rest.indexOf("/");
+    const name = slash < 0 ? rest : rest.slice(0, slash);
+    if (name) return name;
+  }
+  return basename5(cwd) || "unknown";
+}
+function normalizeToolName(name) {
+  const mcp = /^mcp__[0-9a-fA-F-]{16,}__(.+)$/.exec(name);
+  const base = mcp ? `mcp__${mcp[1]}` : name;
+  return base.length > MAX_TOOL_NAME ? base.slice(0, MAX_TOOL_NAME) : base;
+}
+function boundTools(tools) {
+  const merged = {};
+  for (const [name, count] of Object.entries(tools)) {
+    const key = normalizeToolName(name);
+    merged[key] = (merged[key] ?? 0) + count;
+  }
+  const entries = Object.entries(merged).sort((a, b) => b[1] - a[1]);
+  if (entries.length <= MAX_REPORTED_TOOLS) return Object.fromEntries(entries);
+  const out = Object.fromEntries(entries.slice(0, MAX_REPORTED_TOOLS));
+  const tail = entries.slice(MAX_REPORTED_TOOLS);
+  out.__other__ = tail.reduce((sum, [, count]) => sum + count, 0);
+  out.__other_tools__ = tail.length;
+  return out;
+}
+function toSummary(state) {
+  const { firstTs, lastTs } = state;
+  return {
+    schema_version: SESSION_SUMMARY_SCHEMA_VERSION,
+    source: "orgx_session_summary",
+    session_id: state.session_id,
+    source_client: state.source_client,
+    repo: state.repo,
+    cwd: state.cwd,
+    day: firstTs === null ? "unknown" : new Date(firstTs).toISOString().slice(0, 10),
+    started_at: firstTs === null ? null : new Date(firstTs).toISOString(),
+    ended_at: lastTs === null ? null : new Date(lastTs).toISOString(),
+    duration_min: firstTs !== null && lastTs !== null ? Math.round((lastTs - firstTs) / 6e4) : 0,
+    events: state.events,
+    prompts: state.prompts,
+    tool_calls: state.tool_calls,
+    tools: boundTools(state.tools),
+    edits: state.edits,
+    bash: state.bash
+  };
+}
+function percentile(sorted, p) {
+  if (sorted.length === 0) return 0;
+  return sorted[Math.min(sorted.length - 1, Math.floor(sorted.length * p))] ?? 0;
+}
+async function distillSpool(spoolPath) {
+  const sessions = /* @__PURE__ */ new Map();
+  let lines = 0;
+  let badLines = 0;
+  const reader = createInterface({
+    input: createReadStream(spoolPath),
+    crlfDelay: Infinity
+  });
+  for await (const line of reader) {
+    lines += 1;
+    if (!line.trim()) continue;
+    let record;
+    try {
+      record = JSON.parse(line);
+    } catch {
+      badLines += 1;
+      continue;
+    }
+    const sessionId = typeof record.session_id === "string" ? record.session_id : "unknown";
+    const cwd = typeof record.cwd === "string" ? record.cwd : null;
+    const timestamp = typeof record.timestamp === "string" ? Date.parse(record.timestamp) : NaN;
+    const ts = Number.isFinite(timestamp) ? timestamp : null;
+    let state = sessions.get(sessionId);
+    if (!state) {
+      state = {
+        session_id: sessionId,
+        source_client: typeof record.source_client === "string" ? record.source_client : "unknown",
+        repo: repoOf(cwd),
+        cwd,
+        firstTs: ts,
+        lastTs: ts,
+        events: 0,
+        prompts: 0,
+        tool_calls: 0,
+        tools: {},
+        edits: 0,
+        bash: 0
+      };
+      sessions.set(sessionId, state);
+    }
+    state.events += 1;
+    if (ts !== null) {
+      if (state.firstTs === null || ts < state.firstTs) state.firstTs = ts;
+      if (state.lastTs === null || ts > state.lastTs) state.lastTs = ts;
+    }
+    if (cwd && state.cwd === null) {
+      state.cwd = cwd;
+      state.repo = repoOf(cwd);
+    }
+    if (typeof record.source_client === "string" && state.source_client === "unknown") {
+      state.source_client = record.source_client;
+    }
+    const event = typeof record.event === "string" ? record.event : "unknown";
+    if (event === "UserPromptSubmit" || event.includes("user_prompt")) state.prompts += 1;
+    const summary = record.summary;
+    const tool = summary && typeof summary.tool_name === "string" ? summary.tool_name : null;
+    if (tool && (event === "PostToolUse" || event.includes("post_tool_use"))) {
+      state.tool_calls += 1;
+      state.tools[tool] = (state.tools[tool] ?? 0) + 1;
+      if (tool === "Write" || tool === "Edit" || tool === "NotebookEdit") state.edits += 1;
+      if (tool === "Bash") state.bash += 1;
+    }
+  }
+  const summaries = [...sessions.values()].map(toSummary).sort((a, b) => (a.started_at ?? "").localeCompare(b.started_at ?? ""));
+  const sizes = summaries.map((summary) => Buffer.byteLength(JSON.stringify(summary), "utf8")).sort((a, b) => a - b);
+  const total = sizes.reduce((sum, value) => sum + value, 0);
+  let spoolBytes = 0;
+  try {
+    spoolBytes = statSync5(spoolPath).size;
+  } catch {
+    spoolBytes = 0;
+  }
+  return {
+    spoolPath,
+    spoolBytes,
+    lines,
+    badLines,
+    summaries,
+    bytes: {
+      total,
+      max: sizes.at(-1) ?? 0,
+      p50: percentile(sizes, 0.5),
+      p90: percentile(sizes, 0.9),
+      mean: sizes.length > 0 ? Math.round(total / sizes.length) : 0
+    }
+  };
+}
+async function postSummaries(summaries, post, options = {}) {
+  const maxConsecutiveFailures = options.maxConsecutiveFailures ?? 5;
+  const result = { attempted: 0, posted: 0, failed: 0 };
+  let consecutiveFailures = 0;
+  for (const summary of summaries) {
+    result.attempted += 1;
+    const response = await post(summary);
+    if (response.ok) {
+      result.posted += 1;
+      consecutiveFailures = 0;
+      continue;
+    }
+    result.failed += 1;
+    consecutiveFailures += 1;
+    result.firstError ??= `HTTP ${response.status} for session ${summary.session_id}`;
+    if (consecutiveFailures >= maxConsecutiveFailures) break;
+  }
+  return result;
+}
+function truncateSpool(spoolPath, post, options = {}) {
+  if (!options.force && (post.failed > 0 || post.attempted === 0)) {
+    return {
+      truncated: false,
+      reason: post.attempted === 0 ? "nothing was posted, so there is nothing safe to truncate" : `${post.failed} session(s) failed to post`,
+      bytesReleased: 0
+    };
+  }
+  let bytesReleased = 0;
+  try {
+    bytesReleased = statSync5(spoolPath).size;
+  } catch {
+    return { truncated: false, reason: "spool not found", bytesReleased: 0 };
+  }
+  const stamp = (options.now ?? /* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const archivePath = `${spoolPath}.backfilled-${stamp}`;
+  renameSync2(spoolPath, archivePath);
+  writeFileSync4(spoolPath, "", { encoding: "utf8", mode: 384 });
+  return { truncated: true, archivePath, bytesReleased };
+}
+
+// src/lib/session-summary-queue.ts
+var SESSION_SUMMARY_CAPTURE_VERSION = "orgx-session-summary-capture/v1";
+var SESSION_SUMMARY_CAPTURE_FILE_SUFFIX = ".capture.json";
+var SESSION_SUMMARY_CAPTURE_MAX_BYTES = 16 * 1024;
+function sessionSummaryCaptureFiles(queueDir) {
+  if (!existsSync10(queueDir)) return [];
+  try {
+    return readdirSync7(queueDir).filter((name) => name.endsWith(SESSION_SUMMARY_CAPTURE_FILE_SUFFIX)).sort().map((name) => join9(queueDir, name));
+  } catch {
+    return [];
+  }
+}
+function isRecord4(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isSessionSummary(value) {
+  if (!isRecord4(value)) return false;
+  return typeof value.schema_version === "string" && typeof value.session_id === "string" && typeof value.source_client === "string";
+}
+function workGraphFingerprint(sessionId) {
+  let left = 2166136261;
+  let right = 16777619;
+  for (let index = 0; index < sessionId.length; index += 1) {
+    left = Math.imul(left ^ sessionId.charCodeAt(index), 16777619) >>> 0;
+    right = Math.imul(
+      right ^ sessionId.charCodeAt(sessionId.length - 1 - index),
+      2246822507
+    ) >>> 0;
+  }
+  const seed = `${left.toString(16).padStart(8, "0")}${right.toString(16).padStart(8, "0")}`;
+  return `wgf_${(seed + seed).slice(0, 24)}`;
+}
+function parseSessionSummaryCapture(raw) {
+  if (Buffer.byteLength(raw, "utf8") > SESSION_SUMMARY_CAPTURE_MAX_BYTES) return null;
+  try {
+    const value = JSON.parse(raw);
+    if (!isRecord4(value) || value.schema_version !== SESSION_SUMMARY_CAPTURE_VERSION) return null;
+    if (typeof value.capture_id !== "string" || typeof value.queued_at !== "string" || !isSessionSummary(value.session)) {
+      return null;
+    }
+    if (value.initiative_id !== void 0 && typeof value.initiative_id !== "string") {
+      return null;
+    }
+    return {
+      schema_version: SESSION_SUMMARY_CAPTURE_VERSION,
+      capture_id: value.capture_id,
+      // Captures created by wizard 0.1.56 before this field existed must remain
+      // deliverable. Preserve the uncertainty instead of guessing that an old
+      // snapshot represented a real SessionEnd.
+      capture_kind: value.capture_kind === "turn_boundary" || value.capture_kind === "session_end" ? value.capture_kind : "legacy_unspecified",
+      queued_at: value.queued_at,
+      session: value.session,
+      ...typeof value.initiative_id === "string" ? { initiative_id: value.initiative_id } : {}
+    };
+  } catch {
+    return null;
+  }
+}
+function readSessionSummaryCapture(path) {
+  try {
+    return parseSessionSummaryCapture(readFileSync8(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function buildCaptureEndpoint(path, baseUrl) {
+  return buildOrgxApiUrl(path.replace(/^\/api/, ""), baseUrl);
+}
+function buildWorkGraphFallback(capture) {
+  const summary = buildMinimalCloudSummary(capture.session, {
+    captureId: capture.capture_id,
+    captureKind: capture.capture_kind,
+    queuedAt: capture.queued_at
+  });
+  return {
+    report: {
+      schema_version: "2.0.0",
+      work_graph_fingerprint: workGraphFingerprint(summary.session_id),
+      session_id: summary.session_id,
+      investigation: { schema_version: "2.0.0" },
+      raw_transcripts_sent: false,
+      events: [
+        {
+          source_client: summary.source_client,
+          session_id: summary.session_id,
+          occurred_at: summary.ended_at,
+          metadata: summary
+        }
+      ]
+    }
+  };
+}
+function deliveryBody(capture) {
+  return {
+    session: buildMinimalCloudSummary(capture.session, {
+      captureId: capture.capture_id,
+      captureKind: capture.capture_kind,
+      queuedAt: capture.queued_at
+    }),
+    ...capture.initiative_id ? { initiative_id: capture.initiative_id } : {}
+  };
+}
+async function flushSessionSummaryCaptures(options) {
+  const files = sessionSummaryCaptureFiles(options.queueDir);
+  const limit = Math.max(1, Math.min(options.limit ?? 100, 1e3));
+  const selected = files.slice(0, limit);
+  const headers = {
+    Authorization: `Bearer ${options.auth.apiKey}`,
+    "Content-Type": "application/json"
+  };
+  const primaryUrl = buildCaptureEndpoint(
+    SESSION_SUMMARY_ENDPOINT_PATH,
+    options.auth.baseUrl
+  );
+  const fallbackUrl = buildCaptureEndpoint(
+    SESSION_SUMMARY_FALLBACK_ENDPOINT_PATH,
+    options.auth.baseUrl
+  );
+  const result = {
+    found: files.length,
+    attempted: 0,
+    acknowledged: 0,
+    retained: 0,
+    malformed: 0,
+    fallbackAcknowledged: 0
+  };
+  for (const path of selected) {
+    const capture = readSessionSummaryCapture(path);
+    if (!capture) {
+      result.malformed += 1;
+      result.retained += 1;
+      result.firstError ??= `Malformed capture retained: ${path}`;
+      continue;
+    }
+    result.attempted += 1;
+    let response;
+    let usedFallback = false;
+    try {
+      response = await options.send(primaryUrl, deliveryBody(capture), headers);
+      if (!response.ok && (response.status === 404 || response.status === 405)) {
+        response = await options.send(fallbackUrl, buildWorkGraphFallback(capture), headers);
+        usedFallback = true;
+      }
+    } catch {
+      response = { ok: false, status: 0 };
+    }
+    if (!response.ok) {
+      result.retained += 1;
+      result.firstError ??= `HTTP ${response.status} for ${capture.capture_id}`;
+      if (options.stopOnFailure) break;
+      continue;
+    }
+    try {
+      unlinkSync2(path);
+      result.acknowledged += 1;
+      if (usedFallback) result.fallbackAcknowledged += 1;
+    } catch {
+      result.retained += 1;
+      result.firstError ??= `Acknowledged capture could not be removed: ${path}`;
+    }
+  }
+  return result;
+}
+
+// src/lib/session-summary-flush-lease.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import {
+  closeSync as closeSync2,
+  fsyncSync,
+  mkdirSync as mkdirSync5,
+  openSync as openSync2,
+  readFileSync as readFileSync9,
+  renameSync as renameSync3,
+  statSync as statSync6,
+  unlinkSync as unlinkSync3,
+  writeSync
+} from "fs";
+import { join as join10 } from "path";
+var SESSION_SUMMARY_FLUSH_LOCK_NAME = ".flush.lock";
+var SESSION_SUMMARY_FLUSH_MAX_AGE_MS = 2 * 60 * 60 * 1e3;
+var MALFORMED_LOCK_GRACE_MS = 5 * 60 * 1e3;
+function errorCode(error) {
+  return error && typeof error === "object" && "code" in error ? String(error.code) : null;
+}
+function readLock(path) {
+  try {
+    const value = JSON.parse(readFileSync9(path, "utf8"));
+    if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+    const record = value;
+    return typeof record.token === "string" && typeof record.pid === "number" && Number.isInteger(record.pid) && typeof record.claimed_at === "string" ? {
+      token: record.token,
+      pid: record.pid,
+      claimed_at: record.claimed_at
+    } : null;
+  } catch {
+    return null;
+  }
+}
+function processIsAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return errorCode(error) === "EPERM";
+  }
+}
+function lockAgeMs(path, now) {
+  try {
+    return Math.max(0, now.getTime() - statSync6(path).mtimeMs);
+  } catch {
+    return null;
+  }
+}
+function shouldReclaimLock(path, now, isProcessAlive) {
+  const age = lockAgeMs(path, now);
+  if (age === null) return true;
+  if (age >= SESSION_SUMMARY_FLUSH_MAX_AGE_MS) return true;
+  const record = readLock(path);
+  if (!record) return age >= MALFORMED_LOCK_GRACE_MS;
+  return !isProcessAlive(record.pid);
+}
+function writeLock(path, record) {
+  let descriptor = null;
+  try {
+    descriptor = openSync2(path, "wx", 384);
+    writeSync(descriptor, JSON.stringify(record), void 0, "utf8");
+    fsyncSync(descriptor);
+    return "acquired";
+  } catch (error) {
+    return errorCode(error) === "EEXIST" ? "exists" : "unavailable";
+  } finally {
+    if (descriptor !== null) closeSync2(descriptor);
+  }
+}
+function releaseOwnedLock(path, token) {
+  try {
+    if (readLock(path)?.token === token) unlinkSync3(path);
+  } catch {
+  }
+}
+function claimSessionSummaryFlushLease(queueDir, options = {}) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const pid = options.pid ?? process.pid;
+  const token = options.token ?? randomUUID3();
+  const isProcessAlive = options.isProcessAlive ?? processIsAlive;
+  const path = join10(queueDir, SESSION_SUMMARY_FLUSH_LOCK_NAME);
+  const record = { token, pid, claimed_at: now.toISOString() };
+  try {
+    mkdirSync5(queueDir, { recursive: true, mode: 448 });
+  } catch {
+    return { acquired: false, reason: "unavailable" };
+  }
+  const firstAttempt = writeLock(path, record);
+  if (firstAttempt === "acquired") {
+    return {
+      acquired: true,
+      path,
+      release: () => releaseOwnedLock(path, token)
+    };
+  }
+  if (firstAttempt === "unavailable") {
+    return { acquired: false, reason: "unavailable" };
+  }
+  if (!shouldReclaimLock(path, now, isProcessAlive)) {
+    return { acquired: false, reason: "busy" };
+  }
+  const stalePath = `${path}.stale-${token}`;
+  try {
+    renameSync3(path, stalePath);
+    unlinkSync3(stalePath);
+  } catch {
+    return { acquired: false, reason: "busy" };
+  }
+  const retry = writeLock(path, record);
+  if (retry !== "acquired") {
+    return {
+      acquired: false,
+      reason: retry === "exists" ? "busy" : "unavailable"
+    };
+  }
+  return {
+    acquired: true,
+    path,
+    release: () => releaseOwnedLock(path, token)
+  };
+}
+
 // src/spinner.ts
 import ora from "ora";
 import pc2 from "picocolors";
@@ -14100,40 +15656,40 @@ function createOrgxSpinner(text2) {
 }
 
 // src/lib/workload-diagnosis.ts
-import { closeSync as closeSync2, openSync as openSync2, readSync as readSync2 } from "fs";
-import { resolve as resolve2 } from "path";
+import { closeSync as closeSync3, openSync as openSync3, readSync as readSync2 } from "fs";
+import { resolve as resolve3 } from "path";
 
 // src/lib/workload-diagnosis-schema.ts
-import { z } from "zod";
+import { z as z2 } from "zod";
 var WORKLOAD_DIAGNOSIS_SCHEMA_VERSION = "workload-diagnosis/0.1";
 var SECRET_PATTERN = /(?:\b(?:api[_-]?key|authorization|cookie|access[_-]?token|refresh[_-]?token|client[_-]?secret|password|secret|session|token)\s*[:=]\s*\S+|\bbearer\s+[a-z0-9._~+/=-]{8,}|\b(?:oxk_[a-z0-9_-]{8,}|sk-(?:live|test|proj)?[_-]?[a-z0-9_-]{8,}|[sr]k_(?:live|test)_[a-z0-9_-]{8,}|gh[pousr]_[a-z0-9]{8,}|github_pat_[a-z0-9_]{8,}|glpat-[a-z0-9_-]{16,}|xox[baprs]-[a-z0-9-]{8,}|npm_[a-z0-9]{8,}|sntrys_[a-z0-9_-]{8,}|whsec_[a-z0-9_-]{8,}|SG\.[a-z0-9_-]{16,}\.[a-z0-9_-]{16,}|pypi-[a-z0-9_-]{24,}|dop_v1_[a-f0-9]{16,}|hf_[a-z0-9]{20,}|A(?:KI|SI)A[A-Z0-9]{16}|AIza[a-z0-9_-]{20,})\b|\beyJ[a-z0-9_-]{8,}\.eyJ[a-z0-9_-]{8,}\.[a-z0-9_-]{8,}|[a-z][a-z0-9+.-]*:\/\/[^\s/@:]+:[^\s/@]+@|-----BEGIN [A-Z ]*PRIVATE KEY-----)/i;
 var BASIC_AUTH_SECRET_PATTERN = /\bbasic\s+(?:[a-z0-9+/]{4})*(?:[a-z0-9+/]{4}|[a-z0-9+/]{2}==|[a-z0-9+/]{3}=)(?=$|[^a-z0-9+/=])/i;
 function containsCredentialPattern(value) {
   return SECRET_PATTERN.test(value) || BASIC_AUTH_SECRET_PATTERN.test(value);
 }
-var SafeSummarySchema = z.string().trim().min(1).max(500).refine(
+var SafeSummarySchema = z2.string().trim().min(1).max(500).refine(
   (value) => !/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/.test(value),
   { message: "Control characters are not allowed" }
 ).refine((value) => !containsCredentialPattern(value), {
   message: "Do not include credentials, tokens, passwords, or private keys"
 });
-var SafeResponseText = (max) => z.string().min(1).max(max).refine((value) => !/[\u0000-\u001f\u007f-\u009f]/.test(value), {
+var SafeResponseText = (max) => z2.string().min(1).max(max).refine((value) => !/[\u0000-\u001f\u007f-\u009f]/.test(value), {
   message: "Control characters are not allowed"
 });
-var WorkloadTimeHorizonSchema = z.enum([
+var WorkloadTimeHorizonSchema = z2.enum([
   "single_turn",
   "single_session",
   "multi_day",
   "recurring",
   "continuous"
 ]);
-var WorkloadCoordinationSchema = z.enum([
+var WorkloadCoordinationSchema = z2.enum([
   "none",
   "handoff",
   "parallel",
   "hierarchical"
 ]);
-var WorkloadSystemCategorySchema = z.enum([
+var WorkloadSystemCategorySchema = z2.enum([
   "code_repository",
   "issue_tracker",
   "document_store",
@@ -14147,20 +15703,20 @@ var WorkloadSystemCategorySchema = z.enum([
   "identity",
   "other"
 ]);
-var WorkloadAccessModeSchema = z.enum(["read", "write", "admin"]);
-var WorkloadSideEffectSchema = z.enum([
+var WorkloadAccessModeSchema = z2.enum(["read", "write", "admin"]);
+var WorkloadSideEffectSchema = z2.enum([
   "none",
   "reversible",
   "external",
   "irreversible"
 ]);
-var WorkloadDataClassSchema = z.enum([
+var WorkloadDataClassSchema = z2.enum([
   "public",
   "internal",
   "confidential",
   "regulated"
 ]);
-var WorkloadActionSchema = z.enum([
+var WorkloadActionSchema = z2.enum([
   "research",
   "draft",
   "read_internal_data",
@@ -14173,28 +15729,28 @@ var WorkloadActionSchema = z.enum([
   "change_permissions",
   "delete_data"
 ]);
-var WorkloadApprovalPolicySchema = z.enum([
+var WorkloadApprovalPolicySchema = z2.enum([
   "not_applicable",
   "per_action",
   "sensitive_actions",
   "exceptions_only",
   "undefined"
 ]);
-var WorkloadBudgetControlSchema = z.enum([
+var WorkloadBudgetControlSchema = z2.enum([
   "not_applicable",
   "fixed_limit",
   "dynamic_limit",
   "unbounded",
   "undefined"
 ]);
-var SystemAccessSchema = z.object({
+var SystemAccessSchema = z2.object({
   category: WorkloadSystemCategorySchema,
   access: WorkloadAccessModeSchema,
   side_effect: WorkloadSideEffectSchema,
   data_class: WorkloadDataClassSchema
 }).strict();
-var AuthoritySchema = z.object({
-  actions: z.array(WorkloadActionSchema).max(11).superRefine((actions, context) => {
+var AuthoritySchema = z2.object({
+  actions: z2.array(WorkloadActionSchema).max(11).superRefine((actions, context) => {
     if (new Set(actions).size !== actions.length) {
       context.addIssue({
         code: "custom",
@@ -14231,21 +15787,21 @@ var AuthoritySchema = z.object({
     });
   }
 });
-var AccountabilitySchema = z.object({
-  evidence: z.enum(["none", "activity_log", "artifact", "verified_outcome"]),
-  acceptance: z.enum(["none", "agent", "human", "downstream_system"]),
-  consequence: z.enum(["low", "moderate", "high", "regulated"]),
-  retention: z.enum(["none", "short_term", "long_term", "regulated"])
+var AccountabilitySchema = z2.object({
+  evidence: z2.enum(["none", "activity_log", "artifact", "verified_outcome"]),
+  acceptance: z2.enum(["none", "agent", "human", "downstream_system"]),
+  consequence: z2.enum(["low", "moderate", "high", "regulated"]),
+  retention: z2.enum(["none", "short_term", "long_term", "regulated"])
 }).strict();
-var WorkloadDiagnosisRequestSchema = z.object({
-  schema_version: z.literal(WORKLOAD_DIAGNOSIS_SCHEMA_VERSION),
-  workload: z.object({
+var WorkloadDiagnosisRequestSchema = z2.object({
+  schema_version: z2.literal(WORKLOAD_DIAGNOSIS_SCHEMA_VERSION),
+  workload: z2.object({
     name: SafeSummarySchema.max(120),
     outcome: SafeSummarySchema,
     time_horizon: WorkloadTimeHorizonSchema,
-    agent_count: z.number().int().min(1).max(64),
+    agent_count: z2.number().int().min(1).max(64),
     coordination: WorkloadCoordinationSchema,
-    systems: z.array(SystemAccessSchema).max(12).superRefine((systems, context) => {
+    systems: z2.array(SystemAccessSchema).max(12).superRefine((systems, context) => {
       const seen = /* @__PURE__ */ new Set();
       systems.forEach((system, index) => {
         if (seen.has(system.category)) {
@@ -14325,28 +15881,28 @@ var WorkloadDiagnosisRequestSchema = z.object({
     }
   });
 });
-var BoundaryNameSchema = z.enum([
+var BoundaryNameSchema = z2.enum([
   "time",
   "agents",
   "systems",
   "authority",
   "accountability"
 ]);
-var BoundaryFindingSchema = z.object({
-  state: z.enum(["absent", "present", "critical"]),
-  score: z.number().int().min(0).max(2),
+var BoundaryFindingSchema = z2.object({
+  state: z2.enum(["absent", "present", "critical"]),
+  score: z2.number().int().min(0).max(2),
   reason: SafeResponseText(300)
 }).strict();
-var ProposedResourceSchema = z.object({
+var ProposedResourceSchema = z2.object({
   resource: SafeResponseText(80),
   requested_access: WorkloadAccessModeSchema,
-  scope_intents: z.array(SafeResponseText(80)).min(1).max(12),
+  scope_intents: z2.array(SafeResponseText(80)).min(1).max(12),
   purpose: SafeResponseText(300),
-  credential_input_required: z.literal(false)
+  credential_input_required: z2.literal(false)
 }).strict();
-var HumanApprovalSchema = z.object({
-  id: z.string().regex(/^[a-z0-9_-]{1,80}$/),
-  owner_role: z.enum([
+var HumanApprovalSchema = z2.object({
+  id: z2.string().regex(/^[a-z0-9_-]{1,80}$/),
+  owner_role: z2.enum([
     "workload_owner",
     "system_owner",
     "code_owner",
@@ -14355,63 +15911,63 @@ var HumanApprovalSchema = z.object({
     "identity_admin",
     "data_owner"
   ]),
-  timing: z.enum([
+  timing: z2.enum([
     "before_installation",
     "before_first_use",
     "per_action",
     "when_threshold_exceeded"
   ]),
   decision: SafeResponseText(300),
-  scope: z.array(SafeResponseText(100)).min(1).max(16)
+  scope: z2.array(SafeResponseText(100)).min(1).max(16)
 }).strict();
-var WorkloadDiagnosisResponseSchema = z.object({
-  schema_version: z.literal(WORKLOAD_DIAGNOSIS_SCHEMA_VERSION),
-  diagnosis_id: z.string().regex(/^wdg_[a-f0-9]{24}$/),
-  recommendation: z.object({
-    verdict: z.enum(["needed", "conditional", "not_needed"]),
-    mode: z.enum(["none", "receipt_only", "governed_workspace"]),
+var WorkloadDiagnosisResponseSchema = z2.object({
+  schema_version: z2.literal(WORKLOAD_DIAGNOSIS_SCHEMA_VERSION),
+  diagnosis_id: z2.string().regex(/^wdg_[a-f0-9]{24}$/),
+  recommendation: z2.object({
+    verdict: z2.enum(["needed", "conditional", "not_needed"]),
+    mode: z2.enum(["none", "receipt_only", "governed_workspace"]),
     summary: SafeResponseText(400),
-    rationale: z.array(SafeResponseText(300)).max(5),
-    active_boundary_count: z.number().int().min(0).max(5)
+    rationale: z2.array(SafeResponseText(300)).max(5),
+    active_boundary_count: z2.number().int().min(0).max(5)
   }).strict(),
-  boundaries: z.object({
+  boundaries: z2.object({
     time: BoundaryFindingSchema,
     agents: BoundaryFindingSchema,
     systems: BoundaryFindingSchema,
     authority: BoundaryFindingSchema,
     accountability: BoundaryFindingSchema
   }).strict(),
-  missing_capabilities: z.array(
-    z.object({
-      id: z.string().regex(/^[a-z0-9_]{1,60}$/),
+  missing_capabilities: z2.array(
+    z2.object({
+      id: z2.string().regex(/^[a-z0-9_]{1,60}$/),
       boundary: BoundaryNameSchema,
       reason: SafeResponseText(300)
     }).strict()
   ).max(15),
-  proposed_resources: z.array(ProposedResourceSchema).max(13),
-  what_remains_local: z.array(
-    z.object({
+  proposed_resources: z2.array(ProposedResourceSchema).max(13),
+  what_remains_local: z2.array(
+    z2.object({
       item: SafeResponseText(100),
       reason: SafeResponseText(300)
     }).strict()
   ).min(1).max(6),
-  risks: z.array(
-    z.object({
-      id: z.string().regex(/^[a-z0-9_]{1,60}$/),
-      severity: z.enum(["low", "medium", "high", "critical"]),
+  risks: z2.array(
+    z2.object({
+      id: z2.string().regex(/^[a-z0-9_]{1,60}$/),
+      severity: z2.enum(["low", "medium", "high", "critical"]),
       boundary: BoundaryNameSchema,
       description: SafeResponseText(300),
       mitigation: SafeResponseText(300)
     }).strict()
   ).max(15),
-  capabilities_after_installation: z.array(SafeResponseText(300)).max(10),
-  human_approvals: z.array(HumanApprovalSchema).max(32),
-  approval_handoff: z.object({
-    kind: z.enum(["none", "browser_review"]),
-    url: z.string().url().nullable(),
-    mutates_state: z.literal(false),
-    carries_sensitive_data: z.boolean(),
-    approval_ids: z.array(z.string().regex(/^[a-z0-9_-]{1,80}$/)).max(32)
+  capabilities_after_installation: z2.array(SafeResponseText(300)).max(10),
+  human_approvals: z2.array(HumanApprovalSchema).max(32),
+  approval_handoff: z2.object({
+    kind: z2.enum(["none", "browser_review"]),
+    url: z2.string().url().nullable(),
+    mutates_state: z2.literal(false),
+    carries_sensitive_data: z2.boolean(),
+    approval_ids: z2.array(z2.string().regex(/^[a-z0-9_-]{1,80}$/)).max(32)
   }).strict()
 }).strict().superRefine((response, context) => {
   const activeCount = Object.values(response.boundaries).filter(
@@ -14454,7 +16010,7 @@ var MAX_HANDOFF_TOKEN_CHARACTERS = 7e3;
 var SENSITIVE_KEY2 = /(?:^|[_-])(?:authorization|cookie|credentials?|password|secrets?|session|tokens?|api[_-]?keys?|access[_-]?tokens?|refresh[_-]?tokens?|client[_-]?secrets?|private[_-]?keys?|database[_-]?(?:url|uri)|db[_-]?(?:url|uri))(?:$|[_-])/i;
 function readBoundedUtf8(source) {
   const shouldClose = source !== "-";
-  const fd = shouldClose ? openSync2(resolve2(source), "r") : 0;
+  const fd = shouldClose ? openSync3(resolve3(source), "r") : 0;
   const buffer = Buffer.alloc(MAX_WORKLOAD_DIAGNOSIS_REQUEST_BYTES + 1);
   let offset = 0;
   try {
@@ -14470,7 +16026,7 @@ function readBoundedUtf8(source) {
       offset += bytesRead;
     }
   } finally {
-    if (shouldClose) closeSync2(fd);
+    if (shouldClose) closeSync3(fd);
   }
   if (offset > MAX_WORKLOAD_DIAGNOSIS_REQUEST_BYTES) {
     throw new Error(
@@ -14825,8 +16381,171 @@ function printRuntimeHookInspection(report) {
   console.log(`  ${report.codex.hooksEnabled ? ICON.ok : ICON.warn}  ${pc3.bold("Codex flag  ")} ${report.codex.hooksEnabled ? pc3.green("enabled") : pc3.yellow("not enabled")}  ${pc3.dim(report.paths.codexConfigPath)}`);
   console.log(`  ${report.codex.notifyPreserved ? ICON.ok : ICON.warn}  ${pc3.bold("notify      ")} ${report.codex.notifyPreserved ? pc3.green("preserved") : pc3.yellow("check config")}  ${pc3.dim(report.codex.hasNotify ? "existing notify detected" : "no notify entry")}`);
   console.log(`  ${report.installed.claudeCode ? ICON.ok : ICON.warn}  ${pc3.bold("Claude Code ")} ${report.installed.claudeCode ? pc3.green("installed") : pc3.yellow("missing")}  ${pc3.dim(report.paths.claudeSettingsPath)}`);
+  console.log(`  ${report.installed.summaryHookScript ? ICON.ok : ICON.warn}  ${pc3.bold("summary hook")} ${report.installed.summaryHookScript ? pc3.green("installed") : pc3.yellow("missing")}  ${pc3.dim(report.paths.summaryHookScriptPath)}`);
+  console.log(`  ${report.installed.automaticDelivery ? ICON.ok : ICON.warn}  ${pc3.bold("auto delivery")} ${report.installed.automaticDelivery ? pc3.green("configured") : pc3.yellow("not configured")}  ${pc3.dim("detached, ACK-gated worker")}`);
+  console.log(`  ${ICON.skip}  ${pc3.bold("capture queue")} ${pc3.dim(`${report.sessionSummaryCaptures} capture${report.sessionSummaryCaptures === 1 ? "" : "s"} at ${report.paths.sessionSummaryQueueDir}`)}`);
   console.log(`  ${ICON.skip}  ${pc3.bold("outbox      ")} ${pc3.dim(`${report.outboxEvents} event${report.outboxEvents === 1 ? "" : "s"} at ${report.paths.outboxPath}`)}`);
 }
+function printSessionSummaryFlush(result) {
+  if (result.skipped) {
+    console.log(`  ${ICON.skip}  ${pc3.bold("captures    ")} ${pc3.dim(result.skipped.replaceAll("_", " "))}`);
+    return;
+  }
+  const delivered = `${result.acknowledged}/${result.attempted} acknowledged`;
+  console.log(`  ${result.retained === 0 ? ICON.ok : ICON.warn}  ${pc3.bold("captures    ")} ${pc3.dim(`${delivered}, ${result.retained} retained, ${result.malformed} malformed`)}`);
+  if (result.fallbackAcknowledged > 0) {
+    console.log(`  ${ICON.warn}  ${pc3.bold("fallback    ")} ${pc3.dim(`${result.fallbackAcknowledged} capture(s) delivered through the legacy Work Graph endpoint`)}`);
+  }
+  if (result.firstError) console.log(`  ${ICON.warn}  ${pc3.dim(result.firstError)}`);
+}
+async function runSessionSummaryFlushCommand(options) {
+  const queueDir = resolve4(options.queue?.trim() || inspectRuntimeHooks().paths.sessionSummaryQueueDir);
+  const found = sessionSummaryCaptureFiles(queueDir).length;
+  let result;
+  if (found === 0) {
+    result = {
+      found: 0,
+      attempted: 0,
+      acknowledged: 0,
+      retained: 0,
+      malformed: 0,
+      fallbackAcknowledged: 0,
+      skipped: "empty_queue"
+    };
+  } else {
+    const lease = claimSessionSummaryFlushLease(queueDir);
+    if (!lease.acquired) {
+      if (lease.reason === "unavailable") {
+        if (options.background) return;
+        throw new Error(`Could not acquire the session-summary flush lease at ${queueDir}.`);
+      }
+      result = {
+        found,
+        attempted: 0,
+        acknowledged: 0,
+        retained: 0,
+        malformed: 0,
+        fallbackAcknowledged: 0,
+        skipped: "already_running"
+      };
+    } else {
+      try {
+        const auth = await resolveOrgxAuth();
+        if (!auth) {
+          if (options.background) return;
+          throw new Error("No OrgX credential found. Run `orgx-wizard login` first.");
+        }
+        result = await flushSessionSummaryCaptures({
+          queueDir,
+          auth,
+          limit: parsePositiveInt(options.limit, 100),
+          stopOnFailure: options.background === true,
+          send: async (url, body, headers) => {
+            try {
+              const response = await fetchWithRetry(
+                url,
+                {
+                  method: "POST",
+                  headers,
+                  body: JSON.stringify(body)
+                },
+                options.background ? { timeoutMs: 8e3, retries: 0 } : { timeoutMs: 12e3, retries: 1 }
+              );
+              return { ok: response.ok, status: response.status };
+            } catch {
+              return { ok: false, status: 0 };
+            }
+          }
+        });
+      } finally {
+        lease.release();
+      }
+    }
+  }
+  if (options.background) return;
+  await safeTrackWizardTelemetry("hooks_session_summary_flush_ran", {
+    command: "hooks flush",
+    attempted: String(result.attempted),
+    acknowledged: String(result.acknowledged),
+    retained: String(result.retained)
+  });
+  if (result.retained > 0) process.exitCode = 1;
+  if (options.json) {
+    console.log(JSON.stringify({ ok: result.retained === 0, queueDir, ...result }, null, 2));
+    return;
+  }
+  printSessionSummaryFlush(result);
+}
+async function runHookBackfillCommand(options) {
+  const paths = inspectRuntimeHooks().paths;
+  const spoolPath = resolve4(options.spool?.trim() || paths.outboxPath);
+  if (!fileExists(spoolPath)) {
+    const message = `No hook spool found at ${spoolPath}`;
+    if (options.json) {
+      console.log(JSON.stringify({ ok: true, distilled: 0, reason: "missing_spool", spoolPath }, null, 2));
+      return;
+    }
+    console.log(`  ${ICON.skip}  ${pc3.dim(message)}`);
+    return;
+  }
+  if ((options.post || options.truncate) && !options.yes) {
+    throw new Error("Posting or truncating the hook spool requires --yes. Run without --post to preview.");
+  }
+  if (options.truncate && !options.post) {
+    throw new Error("--truncate is only valid together with --post; nothing may be discarded unsent.");
+  }
+  const distilled = await distillSpool(spoolPath);
+  const reduction = distilled.bytes.total > 0 ? Math.round(distilled.spoolBytes / distilled.bytes.total) : 0;
+  let post = { attempted: 0, posted: 0, failed: 0 };
+  let truncation = { truncated: false, bytesReleased: 0 };
+  if (options.post) {
+    const auth = await resolveOrgxAuth();
+    if (!auth) {
+      throw new Error("No OrgX credential found. Run `orgx-wizard login` first.");
+    }
+    const url = `${auth.baseUrl.replace(/\/+$/, "")}${SESSION_SUMMARY_ENDPOINT_PATH}`;
+    post = await postSummaries(distilled.summaries, async (summary) => {
+      const minimalSummary = buildMinimalCloudSummary(summary, {
+        captureKind: "historical_backfill"
+      });
+      const response = await fetchWithRetry(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${auth.apiKey}` },
+        body: JSON.stringify({ session: minimalSummary, backfill: true })
+      });
+      return { ok: response.ok, status: response.status };
+    });
+    if (options.truncate) {
+      truncation = truncateSpool(spoolPath, post);
+    }
+  }
+  const result = {
+    ok: true,
+    spoolPath,
+    spoolBytes: distilled.spoolBytes,
+    lines: distilled.lines,
+    badLines: distilled.badLines,
+    sessions: distilled.summaries.length,
+    payloadBytes: distilled.bytes,
+    reductionFactor: reduction,
+    posted: options.post ? post : null,
+    truncated: options.truncate ? truncation : null
+  };
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(`  ${ICON.ok}  ${pc3.bold("spool       ")} ${pc3.dim(`${(distilled.spoolBytes / 1048576).toFixed(1)}MB, ${distilled.lines} lines, ${distilled.badLines} unparsable`)}`);
+  console.log(`  ${ICON.ok}  ${pc3.bold("distilled   ")} ${pc3.dim(`${distilled.summaries.length} sessions, ${(distilled.bytes.total / 1024).toFixed(0)}KB total (p50 ${distilled.bytes.p50}B, max ${distilled.bytes.max}B), ${reduction}x smaller`)}`);
+  if (!options.post) {
+    console.log(`  ${ICON.skip}  ${pc3.dim("preview only. Re-run with --post --yes to upload, and add --truncate to archive the spool.")}`);
+    return;
+  }
+  console.log(`  ${post.failed === 0 ? ICON.ok : ICON.warn}  ${pc3.bold("posted      ")} ${pc3.dim(`${post.posted}/${post.attempted} sessions${post.firstError ? ` (${post.firstError})` : ""}`)}`);
+  if (options.truncate) {
+    console.log(`  ${truncation.truncated ? ICON.ok : ICON.warn}  ${pc3.bold("truncated   ")} ${pc3.dim(truncation.truncated ? `${(truncation.bytesReleased / 1048576).toFixed(1)}MB archived to ${truncation.archivePath}` : `skipped: ${truncation.reason}`)}`);
+  }
+}
 function requireHookReplayApproval(options, interactive) {
   if (options.yes) return true;
   if (!interactive) {
@@ -14857,7 +16576,7 @@ async function runHookReplayCommand(options) {
   }
   const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
   const paths = inspectRuntimeHooks().paths;
-  const outboxPath = resolve3(options.outbox?.trim() || paths.outboxPath);
+  const outboxPath = resolve4(options.outbox?.trim() || paths.outboxPath);
   const readResult = readRuntimeHookOutbox(outboxPath, parsePositiveInt(options.limit, 200));
   const replay = buildWorkGraphHookReplayPatch(readResult);
   if (replay.records === 0) {
@@ -14889,10 +16608,10 @@ async function runHookReplayCommand(options) {
 }
 function readAuditInput(options, interactive) {
   if (options.input?.trim()) {
-    return readFileSync8(resolve3(options.input.trim()), "utf8");
+    return readFileSync10(resolve4(options.input.trim()), "utf8");
   }
   if (!process.stdin.isTTY) {
-    return readFileSync8(0, "utf8");
+    return readFileSync10(0, "utf8");
   }
   if (!interactive) {
     throw new Error("Audit input is required. Pass --input <file> or pipe text into wizard audit.");
@@ -14924,8 +16643,8 @@ function collectPathOption(value, previous = []) {
   ];
 }
 function parseClientExtractionFile(path) {
-  const resolvedPath = resolve3(path);
-  const parsed = JSON.parse(readFileSync8(resolvedPath, "utf8"));
+  const resolvedPath = resolve4(path);
+  const parsed = JSON.parse(readFileSync10(resolvedPath, "utf8"));
   if (!isRecord(parsed)) {
     throw new Error(`AI-client extraction must be a JSON object: ${resolvedPath}`);
   }
@@ -14947,8 +16666,8 @@ async function readAuditImports(options, interactive) {
   const missingSources = [];
   if (sources.length > 0) {
     const imported = loadAiSessionImports({
-      ...options.claudeProjectsDir?.trim() ? { claudeProjectsDir: resolve3(options.claudeProjectsDir.trim()) } : {},
-      ...options.codexSessionsDir?.trim() ? { codexSessionsDir: resolve3(options.codexSessionsDir.trim()) } : {},
+      ...options.claudeProjectsDir?.trim() ? { claudeProjectsDir: resolve4(options.claudeProjectsDir.trim()) } : {},
+      ...options.codexSessionsDir?.trim() ? { codexSessionsDir: resolve4(options.codexSessionsDir.trim()) } : {},
       limitPerSource: parsePositiveInteger(options.sessionLimit, 3, "--session-limit"),
       sinceDays: parsePositiveInteger(options.sessionDays, 30, "--session-days"),
       sources
@@ -14988,8 +16707,8 @@ async function readWorkGraphInputs(options, interactive) {
   const clientExtractions = readClientExtractions(options);
   const investigationSources = parseInvestigationSourceList(options.from);
   const investigationSourceData = investigationSources.length > 0 ? loadWorkGraphInvestigationSourceData({
-    ...options.claudeProjectsDir?.trim() ? { claudeProjectsDir: resolve3(options.claudeProjectsDir.trim()) } : {},
-    ...options.codexSessionsDir?.trim() ? { codexSessionsDir: resolve3(options.codexSessionsDir.trim()) } : {},
+    ...options.claudeProjectsDir?.trim() ? { claudeProjectsDir: resolve4(options.claudeProjectsDir.trim()) } : {},
+    ...options.codexSessionsDir?.trim() ? { codexSessionsDir: resolve4(options.codexSessionsDir.trim()) } : {},
     cwd: process.cwd(),
     limitPerSource: parsePositiveInteger(options.sessionLimit, 8, "--session-limit"),
     sinceDays: parsePositiveInteger(options.sessionDays, 45, "--session-days"),
@@ -15106,10 +16825,10 @@ async function runAuditCommand(options) {
     workspace
   });
   const markdown = renderSelfAuditMarkdown(plan);
-  const outputDir = resolve3(options.outputDir?.trim() || ".orgx/audits");
+  const outputDir = resolve4(options.outputDir?.trim() || ".orgx/audits");
   const timestamp = plan.generated_at.replace(/[:.]/g, "-");
-  const jsonPath = resolve3(outputDir, `ai-native-self-audit-${timestamp}.json`);
-  const markdownPath = resolve3(outputDir, `ai-native-self-audit-${timestamp}.md`);
+  const jsonPath = resolve4(outputDir, `ai-native-self-audit-${timestamp}.json`);
+  const markdownPath = resolve4(outputDir, `ai-native-self-audit-${timestamp}.md`);
   writeJsonFile(jsonPath, plan);
   writeTextFile(markdownPath, markdown);
   if (options.json) {
@@ -15240,7 +16959,7 @@ async function runOperatingMapCommand(queryParts, options) {
 }
 function runWorkGraphExtractionSchemaCommand(options) {
   const protocol = buildWorkGraphExtractionProtocol();
-  const outputPath = options.output?.trim() ? resolve3(options.output.trim()) : "";
+  const outputPath = options.output?.trim() ? resolve4(options.output.trim()) : "";
   if (outputPath) {
     if (options.json) {
       writeJsonFile(outputPath, protocol);
@@ -15270,8 +16989,8 @@ function normalizeRuntimePacketRole(role) {
 }
 function runWorkGraphRuntimeEventCommand(options) {
   const source = normalizeRuntimePacketSource(options.source);
-  const cwd = resolve3(options.cwd?.trim() || process.cwd());
-  const outputRoot = resolve3(cwd, options.outputDir?.trim() || ".orgx/work-graph/runtime-events");
+  const cwd = resolve4(options.cwd?.trim() || process.cwd());
+  const outputRoot = resolve4(cwd, options.outputDir?.trim() || ".orgx/work-graph/runtime-events");
   const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
   const timestamp = generatedAt.replace(/[:.]/g, "-");
   const summary = options.summary?.trim() || options.message?.trim();
@@ -15292,7 +17011,7 @@ function runWorkGraphRuntimeEventCommand(options) {
     collection_method: "runtime_packet",
     redaction_state: "agent_redacted"
   };
-  const path = resolve3(outputRoot, source, `${timestamp}-${process.pid}.jsonl`);
+  const path = resolve4(outputRoot, source, `${timestamp}-${process.pid}.jsonl`);
   writeTextFile(path, `${JSON.stringify(packet)}
 `, { mode: 384 });
   if (options.json) {
@@ -15335,11 +17054,11 @@ async function runWorkGraphCommand(options, defaults = {}) {
     workspace
   });
   const markdown = renderWorkGraphMarkdown(report);
-  const outputDir = resolve3(commandOptions.outputDir?.trim() || ".orgx/work-graph");
+  const outputDir = resolve4(commandOptions.outputDir?.trim() || ".orgx/work-graph");
   const timestamp = report.generated_at.replace(/[:.]/g, "-");
-  const jsonPath = resolve3(outputDir, `work-graph-report-${timestamp}.json`);
-  const markdownPath = resolve3(outputDir, `work-graph-report-${timestamp}.md`);
-  const agentBriefPath = resolve3(outputDir, `work-graph-agent-brief-${timestamp}.md`);
+  const jsonPath = resolve4(outputDir, `work-graph-report-${timestamp}.json`);
+  const markdownPath = resolve4(outputDir, `work-graph-report-${timestamp}.md`);
+  const agentBriefPath = resolve4(outputDir, `work-graph-agent-brief-${timestamp}.md`);
   writeJsonFile(jsonPath, report);
   writeTextFile(markdownPath, markdown);
   let published = null;
@@ -15754,14 +17473,14 @@ async function readSingleKey() {
   const stdin = process.stdin;
   if (!stdin.isTTY) return null;
   const previousRawMode = stdin.isRaw === true;
-  return await new Promise((resolve4) => {
+  return await new Promise((resolve5) => {
     const cleanup = (result) => {
       stdin.off("data", onData);
       if (stdin.isTTY) {
         stdin.setRawMode(previousRawMode);
       }
       stdin.pause();
-      resolve4(result);
+      resolve5(result);
     };
     const onData = (chunk) => {
       const text2 = chunk.toString("utf8");
@@ -16526,7 +18245,7 @@ async function main() {
   initializeWizardSentry();
   const program = new Command();
   program.name("orgx-wizard").description("Add OrgX MCP configs, skills/rules, and companion plugins to your local AI tools.").showHelpAfterError();
-  const pkgVersion = true ? "0.1.56" : void 0;
+  const pkgVersion = true ? "0.1.57" : void 0;
   program.version(pkgVersion ?? "unknown", "-V, --version");
   program.hook("preAction", (_thisCommand, actionCommand) => {
     if (Boolean(actionCommand.optsWithGlobals().json)) return;
@@ -17326,9 +19045,15 @@ async function main() {
       }
     }
   });
+  hooks.command("flush").description("Deliver queued session summaries and retain every unacknowledged capture.").option("--queue <path>", "session-summary capture queue path").option("--limit <count>", "maximum queued captures to attempt", "100").option("--background", "run quietly as a hook-triggered delivery worker").option("--json", "emit a JSON command summary").action(async (options) => {
+    await runSessionSummaryFlushCommand(options);
+  });
   hooks.command("replay").description("Replay passive hook outbox events into a claimed Work Graph profile.").requiredOption("--fingerprint <fingerprint>", "target Work Graph fingerprint, for example wgf_0123...").option("--outbox <path>", "runtime hook JSONL outbox path").option("--limit <count>", "maximum recent hook events to replay", "200").option("--yes", "approve publishing hook evidence without prompting").option("--json", "emit a JSON command summary").action(async (options) => {
     await runHookReplayCommand(options);
   });
+  hooks.command("backfill").description("Distill the historical hook spool into lean session summaries (preview by default).").option("--spool <path>", "runtime hook JSONL spool path").option("--post", "upload the distilled summaries to OrgX (requires --yes)").option("--truncate", "archive and empty the spool after a fully successful --post (requires --yes)").option("--yes", "confirm uploading or truncating your local work history").option("--json", "emit a JSON command summary").action(async (options) => {
+    await runHookBackfillCommand(options);
+  });
   program.command("doctor").description("Verify OrgX health, or diagnose a credential-free workload shape.").option("--workload <path>", "diagnose a sanitized workload-shape JSON file; use - for stdin").option("--base-url <url>", "explicit workload endpoint override for testing or self-hosting").option("--json", "emit the selected doctor result as JSON").action(async (options) => {
     if (options.baseUrl && !options.workload) {
       const message = "--base-url is only valid together with --workload.";
@@ -17564,4 +19289,4 @@ main().catch(async (error) => {
   process.exitCode = 1;
 });
 //# sourceMappingURL=cli.js.map
-//# debugId=02842523-d681-5cea-96aa-0f0c896e9fb5
+//# debugId=8eca99e4-958f-5704-a1cb-bd96bbd10293