@nurix/nustack 0.23.14 → 0.23.15

package/dist/commands/obligationList.js

@@ -0,0 +1,75 @@
+import { obligationsCachePath } from "../lib/local_store/paths.js";
+import { printJsonError, printJsonSuccess } from "../lib/json_output.js";
+import { resolveProjectId } from "../lib/project_context.js";
+import { getFromDoor, readCache, writeCache } from "../lib/sessions/brief.js";
+const MAX_PAGES = 100;
+const PAGE_TIMEOUT_MS = 10_000;
+function lineOf(item) {
+    if (typeof item.naturalKey !== "string")
+        return null;
+    const payload = (item.payload ?? {});
+    return {
+        naturalKey: item.naturalKey,
+        state: typeof payload.state === "string" ? payload.state : "unknown",
+        verdict: typeof payload.outcome?.verdict === "string" ? payload.outcome.verdict : null,
+    };
+}
+async function fetchAll(root, globals, projectId, plan) {
+    const lines = [];
+    let cursor = null;
+    for (let page = 0; page < MAX_PAGES; page += 1) {
+        const query = `/records?kind=obligation&planAnchor=${encodeURIComponent(plan)}&limit=100${cursor ? `&cursor=${encodeURIComponent(cursor)}` : ""}`;
+        const answered = await getFromDoor(root, globals, projectId, query, PAGE_TIMEOUT_MS);
+        const items = answered?.data?.items;
+        if (!answered || !Array.isArray(items))
+            return null;
+        for (const item of items) {
+            const line = lineOf(item);
+            if (line)
+                lines.push(line);
+        }
+        cursor = answered.meta?.nextCursor ?? null;
+        if (!cursor)
+            return lines;
+    }
+    return lines;
+}
+export async function runObligationList(options, globals) {
+    const root = process.cwd();
+    const project = await resolveProjectId(root, options.project ? { project: options.project } : {});
+    if (!project.ok) {
+        if (options.json)
+            printJsonError("obligation list", { code: "NO_PROJECT", message: project.message });
+        else {
+            process.stderr.write(`obligation list: ${project.message}\n`);
+            process.exitCode = 1;
+        }
+        return;
+    }
+    const cacheFile = obligationsCachePath(project.projectId, options.plan);
+    const fetched = await fetchAll(root, globals, project.projectId, options.plan);
+    let obligations;
+    let source;
+    let fetchedAt = null;
+    if (fetched) {
+        writeCache(cacheFile, fetched);
+        obligations = fetched;
+        source = "server";
+    }
+    else {
+        const cached = readCache(cacheFile);
+        obligations = cached?.value ?? [];
+        fetchedAt = cached?.fetchedAt ?? null;
+        source = "cache";
+    }
+    if (options.json) {
+        printJsonSuccess("obligation list", { plan: options.plan, projectId: project.projectId, source, fetchedAt, obligations });
+        return;
+    }
+    if (source === "cache")
+        process.stderr.write(`obligation list: offline; the cached list${fetchedAt ? ` from ${fetchedAt}` : " is empty"}\n`);
+    for (const line of obligations)
+        process.stdout.write(`${line.naturalKey}  ${line.state}${line.verdict ? ` ${line.verdict}` : ""}\n`);
+    if (obligations.length === 0)
+        process.stdout.write(`obligation list: no obligations under ${options.plan}\n`);
+}

package/dist/commands/recordAliases.js

@@ -3,6 +3,7 @@ import { openLocalStore } from "../lib/local_store/database.js";
 import { idempotencyKeyOf, splitObligationKey } from "../lib/records/naturalKey.js";
 import { findRecordByKey } from "../lib/records/recordsTable.js";
 import { emitRows, refuseEmit, resolveCaller } from "./records.js";
+import { runObligationList } from "./obligationList.js";
 export const RECORD_ALIAS_GROUPS = ["obligation", "backlog", "changelog", "journal"];
 const VERDICTS_NEEDING_REASON = new Set(["owes_nothing", "blocked", "dismissed"]);
 const PLAN_ANCHOR = /^\d{4}-\d{2}-\d{2}-[a-z0-9][a-z0-9-]*$/;
@@ -152,6 +153,13 @@ export function registerRecordAliases(program, getGlobalOptions) {
         .requiredOption("--key <naturalKey>", "the obligation's natural key, <origin>#<type>:<subject>")
         .requiredOption("--outcome <verdict>", "updated, satisfied, fixed, owes_nothing, blocked or dismissed")
         .option("--reason <text>", "why; required for owes_nothing, blocked and dismissed")).action(async (options) => runObligationDischarge(options, getGlobalOptions()));
+    obligation
+        .command("list")
+        .description("List a plan's obligations as NuStack holds them (the cached list when offline)")
+        .requiredOption("--plan <anchor>", "the plan anchor")
+        .option("--project <id>", "the Project, when the folder carries no binding marker")
+        .option("--json", "emit the versioned machine envelope")
+        .action(async (options) => runObligationList(options, getGlobalOptions()));
     withCommon(program
         .command("backlog")
         .description("Log backlog items (harness records)")

package/dist/commands/records.js

@@ -11,6 +11,7 @@ import { DEVICE_TOKEN_VARIABLE, DRAIN_CHILD_VARIABLE, SESSION_ID_VARIABLE, isFla
 import { UNKNOWN_KIND_MESSAGE, assembleRecord, parseRowsText, translateRow, } from "../lib/records/recordInput.js";
 import { AgentOwnedError, OBLIGATION_AGENT_OWNED, countRecords, hasDueRecord, listRecords, releaseUnboundRows, writeRecords, } from "../lib/records/recordsTable.js";
 import { logRefusals } from "../lib/records/refusalLog.js";
+import { drainSessionLegs } from "../lib/sessions/sessionEvents.js";
 async function readStdin() {
     if (process.stdin.isTTY)
         return "";
@@ -35,23 +36,25 @@ export async function resolveCaller(request) {
         },
     };
 }
-export async function refuseEmit(request, code, gate, message, globals, caller) {
+async function logRefusal(request, gate, message, globals, caller) {
     const who = caller ?? (await resolveCaller(request).catch(() => null));
-    if (who) {
+    if (!who)
+        return;
+    try {
+        const store = await openLocalStore();
         try {
-            const store = await openLocalStore();
-            try {
-                if (logRefusals(store, [{ gate, verdict: "block", target: request.target, reason: message }], who.refusalContext) > 0) {
-                    startDetachedDrain({ nustackUrl: globals.nustackUrl });
-                }
-            }
-            finally {
-                store.close();
+            if (logRefusals(store, [{ gate, verdict: "block", target: request.target, reason: message }], who.refusalContext) > 0) {
+                startDetachedDrain({ nustackUrl: globals.nustackUrl });
             }
         }
-        catch {
+        finally {
+            store.close();
         }
     }
+    catch {
+    }
+}
+function printRefusal(request, code, message) {
     if (request.json)
         printJsonError(request.command, { code, message });
     else {
@@ -59,9 +62,16 @@ export async function refuseEmit(request, code, gate, message, globals, caller)
         process.exitCode = 1;
     }
 }
-export async function emitRows(request, globals) {
+export async function refuseEmit(request, code, gate, message, globals, caller) {
+    await logRefusal(request, gate, message, globals, caller);
+    printRefusal(request, code, message);
+}
+export async function writeRecordsLocally(request, globals) {
     const caller = await resolveCaller(request);
-    const refuse = (code, gate, message) => refuseEmit(request, code, gate, message, globals, caller);
+    const refuse = async (code, gate, message) => {
+        await logRefusal(request, gate, message, globals, caller);
+        return { ok: false, code, message };
+    };
     if (!isEmitKind(request.kind))
         return refuse("VALIDATION_FAILED", "records-unknown-kind", UNKNOWN_KIND_MESSAGE);
     const kind = request.kind;
@@ -110,37 +120,44 @@ export async function emitRows(request, globals) {
             owned = error;
             written = [];
         }
-        if (owned)
-            return;
-        if (caller.projectId !== null)
-            releaseUnboundRows(store, caller.root);
-        logRefusals(store, flags.map((flag) => ({
-            gate: "secret-scan",
-            verdict: "flag",
-            target: request.target,
-            reason: `redacted a ${flag.patternId} match at ${flag.path}`,
-        })), caller.refusalContext);
+        if (!owned) {
+            if (caller.projectId !== null)
+                releaseUnboundRows(store, caller.root);
+            logRefusals(store, flags.map((flag) => ({
+                gate: "secret-scan",
+                verdict: "flag",
+                target: request.target,
+                reason: `redacted a ${flag.patternId} match at ${flag.path}`,
+            })), caller.refusalContext);
+        }
     }
     finally {
         store.close();
-        if (owned)
-            await refuse(OBLIGATION_AGENT_OWNED, "agent-owned-obligation", owned.message);
     }
     if (owned)
-        return;
+        return refuse(OBLIGATION_AGENT_OWNED, "agent-owned-obligation", owned.message);
     if (flags.length > 0 || written.some((row) => row.syncState === "pending"))
         startDetachedDrain({ nustackUrl: globals.nustackUrl });
-    const data = {
-        written: written.length,
-        keys: written.map((row) => row.idempotencyKey),
-        local: written.filter((row) => row.syncState === "local").length,
-        flags,
-        projectId: caller.projectId,
+    return {
+        ok: true,
+        data: {
+            written: written.length,
+            keys: written.map((row) => row.idempotencyKey),
+            local: written.filter((row) => row.syncState === "local").length,
+            flags,
+            projectId: caller.projectId,
+        },
     };
+}
+export async function emitRows(request, globals) {
+    const outcome = await writeRecordsLocally(request, globals);
+    if (!outcome.ok)
+        return printRefusal(request, outcome.code, outcome.message);
+    const data = outcome.data;
     if (request.json)
         printJsonSuccess(request.command, data);
     else {
-        for (const flag of flags)
+        for (const flag of data.flags)
             process.stderr.write(`${request.command}: redacted a ${flag.patternId} match at ${flag.path}\n`);
         process.stdout.write(`${request.command}: wrote ${data.written} record(s) locally; sending in the background\n`);
     }
@@ -159,12 +176,18 @@ export async function runRecordsEmit(options, globals) {
     }, globals);
 }
 async function drainAs(store, globals, isChild) {
-    if (!isChild)
-        return drainRecords(store, globals, { isForeground: true });
+    if (!isChild) {
+        const drained = await drainRecords(store, globals, { isForeground: true });
+        await drainSessionLegs(store, globals);
+        return drained;
+    }
     if (!acquireDrainLock())
         return null;
     try {
-        return await drainRecords(store, globals, { onPass: () => refreshDrainLock() });
+        const drained = await drainRecords(store, globals, { onPass: () => refreshDrainLock() });
+        refreshDrainLock();
+        await drainSessionLegs(store, globals);
+        return drained;
     }
     finally {
         releaseDrainLock();

package/dist/commands/session.js

@@ -0,0 +1,222 @@
+import { appendFileSync } from "node:fs";
+import { openLocalStore } from "../lib/local_store/database.js";
+import { printJsonError, printJsonSuccess } from "../lib/json_output.js";
+import { resolveProjectId } from "../lib/project_context.js";
+import { startDetachedDrain } from "../lib/records/drain.js";
+import { SESSION_ID_VARIABLE, readVariable } from "../lib/records/environment.js";
+import { countRefusals } from "../lib/records/refusalLog.js";
+import { scanPayload } from "../lib/records/secretScan.js";
+import { readBrief, renderBrief, renderHookOutput } from "../lib/sessions/brief.js";
+import { parseHookInput, readAllStdin, resolveModel } from "../lib/sessions/hookInput.js";
+import { shipChangedMemory } from "../lib/sessions/memoryShip.js";
+import { mountFacts } from "../lib/sessions/mountFacts.js";
+import { isSessionRuntime, sessionRowIdOf } from "../lib/sessions/sessionKey.js";
+import { readSpool, spoolEvent } from "../lib/sessions/sessionEvents.js";
+import { writeRecordsLocally } from "./records.js";
+async function hookContext(runtimeFlag, raw) {
+    if (!isSessionRuntime(runtimeFlag))
+        return null;
+    const projectDir = readVariable("CLAUDE_PROJECT_DIR");
+    if (runtimeFlag === "claude_code" && !projectDir)
+        return null;
+    const input = parseHookInput(raw);
+    const engineRowId = readVariable(SESSION_ID_VARIABLE);
+    if (!engineRowId && !input.sessionId)
+        return null;
+    const root = projectDir ?? input.cwd ?? process.cwd();
+    const project = await resolveProjectId(root, {});
+    if (!project.ok)
+        return null;
+    return {
+        input,
+        runtime: runtimeFlag,
+        root,
+        projectId: project.projectId,
+        rowId: engineRowId ?? sessionRowIdOf(runtimeFlag, input.sessionId),
+        isEngineSession: engineRowId !== null,
+    };
+}
+const identityOf = (context) => ({
+    rowId: context.rowId,
+    projectId: context.projectId,
+    root: context.root,
+    runtime: context.runtime,
+    runtimeSessionId: context.input.sessionId,
+    isEngineSession: context.isEngineSession,
+});
+async function refusalCountOf(projectId) {
+    try {
+        const store = await openLocalStore();
+        try {
+            return countRefusals(store, { projectId });
+        }
+        finally {
+            store.close();
+        }
+    }
+    catch {
+        return 0;
+    }
+}
+async function runBriefHook(options, globals) {
+    const context = await hookContext(options.runtime, await readAllStdin());
+    if (!context)
+        return;
+    const facts = await mountFacts(context.root, context.runtime);
+    const model = resolveModel(context.input);
+    const event = {
+        sessionId: context.rowId,
+        ...(context.input.sessionId ? { runtimeSessionId: context.input.sessionId } : {}),
+        phase: "start",
+        occurredAt: new Date().toISOString().replace(/\.\d{3}Z$/, "Z"),
+        extension: {
+            runtime: context.runtime,
+            ...(model ? { model } : {}),
+            ...(facts.harnessSemver ? { harnessSemver: facts.harnessSemver } : {}),
+            ...(facts.harnessDigest ? { harnessDigest: facts.harnessDigest } : {}),
+            ...(facts.configDigest ? { configDigest: facts.configDigest } : {}),
+        },
+        isEngineSession: context.isEngineSession,
+    };
+    spoolEvent(identityOf(context), event);
+    const envFile = readVariable("CLAUDE_ENV_FILE");
+    if (envFile) {
+        try {
+            appendFileSync(envFile, `export ${SESSION_ID_VARIABLE}=${context.rowId}\n`);
+        }
+        catch {
+        }
+    }
+    startDetachedDrain({ nustackUrl: globals.nustackUrl });
+    const brief = await readBrief(context.root, globals, context.projectId, context.rowId, await refusalCountOf(context.projectId));
+    process.stdout.write(`${renderHookOutput(brief)}\n`);
+}
+export async function runSessionBrief(options, globals) {
+    if (options.hook) {
+        try {
+            await runBriefHook(options, globals);
+        }
+        catch {
+        }
+        process.exitCode = 0;
+        return;
+    }
+    const root = process.cwd();
+    const project = await resolveProjectId(root, options.project ? { project: options.project } : {});
+    if (!project.ok) {
+        if (options.json)
+            printJsonError("session brief", { code: "NO_PROJECT", message: project.message });
+        else {
+            process.stderr.write(`session brief: ${project.message}\n`);
+            process.exitCode = 1;
+        }
+        return;
+    }
+    const sessionId = options.session ?? readVariable(SESSION_ID_VARIABLE);
+    const brief = await readBrief(root, globals, project.projectId, sessionId, await refusalCountOf(project.projectId));
+    if (options.json)
+        printJsonSuccess("session brief", brief);
+    else
+        process.stdout.write(`${renderBrief(brief)}\n`);
+}
+async function handoverOf(flag) {
+    if (flag === undefined)
+        return null;
+    const raw = (flag === "-" ? await readAllStdin() : flag).trim();
+    if (!raw)
+        return null;
+    const scanned = scanPayload({ handover: raw });
+    return { text: scanned.payload.handover.slice(0, 20_000), flags: scanned.flags.length };
+}
+async function runEndHook(options, globals) {
+    const context = await hookContext(options.runtime, await readAllStdin());
+    if (!context)
+        return;
+    if (context.input.hookEventName === "SessionEnd") {
+        const event = {
+            sessionId: context.rowId,
+            ...(context.input.sessionId ? { runtimeSessionId: context.input.sessionId } : {}),
+            phase: "end",
+            occurredAt: new Date().toISOString().replace(/\.\d{3}Z$/, "Z"),
+            extension: { runtime: context.runtime },
+            isEngineSession: context.isEngineSession,
+        };
+        spoolEvent(identityOf(context), event, { isClosePending: true });
+    }
+    if (context.runtime === "claude_code") {
+        await shipChangedMemory({ repositoryRoot: context.root, projectId: context.projectId, sessionId: context.rowId }, globals, writeRecordsLocally);
+    }
+    startDetachedDrain({ nustackUrl: globals.nustackUrl });
+}
+export async function runSessionEnd(options, globals) {
+    if (options.hook) {
+        try {
+            await runEndHook(options, globals);
+        }
+        catch {
+        }
+        process.exitCode = 0;
+        return;
+    }
+    const refuse = (code, message) => {
+        if (options.json)
+            printJsonError("session end", { code, message });
+        else {
+            process.stderr.write(`session end: ${message}\n`);
+            process.exitCode = 1;
+        }
+    };
+    const handover = await handoverOf(options.handover);
+    if (!handover)
+        return refuse("VALIDATION_FAILED", "a handover is required: --handover <text>, or --handover - to read it from stdin");
+    const rowId = options.session ?? readVariable(SESSION_ID_VARIABLE);
+    if (!rowId)
+        return refuse("NO_SESSION", `no session: run it inside a session (${SESSION_ID_VARIABLE}) or pass --session <id>`);
+    const held = readSpool(rowId);
+    const runtime = held?.runtime ?? (isSessionRuntime(options.runtime) ? options.runtime : "claude_code");
+    let projectId = held?.projectId ?? null;
+    const root = held?.root ?? process.cwd();
+    if (!projectId) {
+        const project = await resolveProjectId(root, options.project ? { project: options.project } : {});
+        if (!project.ok)
+            return refuse("NO_PROJECT", project.message);
+        projectId = project.projectId;
+    }
+    spoolEvent({ rowId, projectId, root, runtime, runtimeSessionId: held?.runtimeSessionId ?? null, isEngineSession: held?.isEngineSession ?? false }, {
+        sessionId: rowId,
+        phase: "end",
+        occurredAt: new Date().toISOString().replace(/\.\d{3}Z$/, "Z"),
+        extension: { runtime, handover: handover.text },
+    });
+    startDetachedDrain({ nustackUrl: globals.nustackUrl });
+    const data = { sessionId: rowId, projectId, redacted: handover.flags };
+    if (options.json)
+        printJsonSuccess("session end", data);
+    else {
+        if (handover.flags > 0)
+            process.stderr.write(`session end: redacted ${handover.flags} secret match(es) in the handover\n`);
+        process.stdout.write("session end: handover recorded; sending in the background\n");
+    }
+}
+export function registerSessionCommands(program, getGlobalOptions) {
+    const session = program.command("session").description("What a session opens with and what it leaves the next one");
+    session
+        .command("brief")
+        .description("The Project's previous handover and open obligations")
+        .option("--hook", "SessionStart hook mode: read the hook JSON on stdin, print the brief as context, always exit 0")
+        .option("--runtime <runtime>", "the runtime reporting: claude_code, codex, opencode, copilot_cli or nustack (required with --hook)")
+        .option("--project <id>", "the Project, when the folder carries no binding marker")
+        .option("--session <id>", `the asking session, left out of the previous handover (default: $${SESSION_ID_VARIABLE})`)
+        .option("--json", "emit the versioned machine envelope")
+        .action(async (options) => runSessionBrief(options, getGlobalOptions()));
+    session
+        .command("end")
+        .description("Leave a handover for the next session; in hook mode, ship memory and close the session")
+        .option("--handover <text>", "the handover; - reads it from stdin")
+        .option("--hook", "Stop / SessionEnd hook mode: read the hook JSON on stdin, always exit 0")
+        .option("--runtime <runtime>", "the runtime reporting (required with --hook)")
+        .option("--session <id>", `the session row (default: $${SESSION_ID_VARIABLE})`)
+        .option("--project <id>", "the Project, when the folder carries no binding marker")
+        .option("--json", "emit the versioned machine envelope")
+        .action(async (options) => runSessionEnd(options, getGlobalOptions()));
+}

package/dist/lib/local_store/paths.js

@@ -19,6 +19,18 @@ export function desktopSettingsPath() {
 export function cacheDir() {
     return path.join(nustackHomeDir(), "cache");
 }
+export function sessionEventsDir() {
+    return path.join(nustackHomeDir(), "session-events");
+}
+export function briefCachePath(projectId) {
+    return path.join(cacheDir(), "brief", `${projectId}.json`);
+}
+export function obligationsCachePath(projectId, planAnchor) {
+    return path.join(cacheDir(), "obligations", projectId, `${planAnchor}.json`);
+}
+export function memoryManifestPath(projectId) {
+    return path.join(cacheDir(), "memory-shipped", `${projectId}.json`);
+}
 export function recoveryDir() {
     return path.join(nustackHomeDir(), "recovery");
 }

package/dist/lib/session-engine/claudeAdapter.js

@@ -72,7 +72,7 @@ export class ClaudeSession {
         }
         if (!this.sessionIdSeen && frame.type === "system" && frame.subtype === "init" && typeof frame.session_id === "string") {
             this.sessionIdSeen = true;
-            this.options.onSessionId?.(frame.session_id);
+            this.options.onSessionId?.(frame.session_id, typeof frame.model === "string" && frame.model ? frame.model : undefined);
         }
         this.options.onEvent(frame);
     }

package/dist/lib/session-engine/supervisor.js

@@ -4,6 +4,8 @@ import { ClaudeSession } from "./claudeAdapter.js";
 import { FRAME_VERSION, parseInboundFrame, serializeFrame, } from "./frames.js";
 import { inspectSession, reclaimSession } from "./prune.js";
 import { sessionRegistryPath, readSessionRegistry, updateSessionRegistry } from "./registry.js";
+import { SESSION_ID_VARIABLE } from "../records/environment.js";
+import { mountFacts } from "../sessions/mountFacts.js";
 import { createSessionWorktree } from "./worktree.js";
 import { readProjectContract } from "../project_contract.js";
 function defaultProbeClaude(env) {
@@ -164,11 +166,18 @@ export class SessionSupervisor {
         };
         if (record.projectId)
             await this.mountInto(sessionId, worktree.worktreePath, record.projectId);
+        const facts = record.projectId ? await mountFacts(worktree.worktreePath, "claude_code") : null;
+        const extension = {
+            runtime: "claude_code",
+            ...(facts?.harnessSemver ? { harnessSemver: facts.harnessSemver } : {}),
+            ...(facts?.harnessDigest ? { harnessDigest: facts.harnessDigest } : {}),
+            ...(facts?.configDigest ? { configDigest: facts.configDigest } : {}),
+        };
         const adapterOptions = {
             cwd: worktree.worktreePath,
             permissionMode,
             resumeSessionId,
-            env: this.env,
+            env: { ...this.env, [SESSION_ID_VARIABLE]: sessionId },
             onEvent: (event) => {
                 this.emit({ v: FRAME_VERSION, type: "session.event", sessionId, event });
                 if (typeof event === "object" && event !== null && event.type === "result") {
@@ -188,12 +197,27 @@ export class SessionSupervisor {
                 });
             },
             onProtocolError: (code, message) => this.error(sessionId, code, message),
-            onSessionId: (vendorSessionId) => {
+            onSessionId: (vendorSessionId, model) => {
                 record.providerSessionId = vendorSessionId;
                 void this.updateRegistry((sessions) => sessions.map((row) => (row.sessionId === sessionId ? { ...row, providerSessionId: vendorSessionId } : row)));
                 const client = this.options.sessions;
                 if (client && record.projectId) {
                     void client.setVendorSessionId(record.projectId, sessionId, vendorSessionId).catch(() => undefined);
+                    void client
+                        .postSessionEvents?.(record.projectId, {
+                        events: [
+                            {
+                                sessionId,
+                                runtimeSessionId: vendorSessionId,
+                                phase: "start",
+                                occurredAt: new Date().toISOString().replace(/\.\d{3}Z$/, "Z"),
+                                extension: { ...extension, ...(model ? { model } : {}) },
+                                isEngineSession: true,
+                            },
+                        ],
+                        labelRows: [],
+                    })
+                        .catch(() => undefined);
                 }
             },
             onExit: (code) => {
@@ -227,6 +251,7 @@ export class SessionSupervisor {
                     vendor: "claude_code",
                     renderer: "claude_transcript",
                     status: "created",
+                    ...extension,
                 });
             }
             catch {

package/dist/lib/sessions/brief.js

@@ -0,0 +1,102 @@
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { ensureAccessToken } from "../auth_grant.js";
+import { briefCachePath } from "../local_store/paths.js";
+import { assertCredentialOrigin } from "../nustack_client.js";
+import { resolveDoor } from "../records/door.js";
+export const BRIEF_FETCH_TIMEOUT_MS = 3_000;
+export const BRIEF_CONTEXT_CAP = 4_000;
+export const BRIEF_CONTEXT_OBLIGATIONS = 20;
+export const HANDOVER_LINE = "Before you finish, leave a handover for the next session: `nustack session end --handover -` with the note on stdin.";
+const EMPTY_BRIEF = { previousHandover: null, openObligations: { total: 0, items: [] }, generatedAt: "" };
+export function readCache(file) {
+    try {
+        const parsed = JSON.parse(readFileSync(file, "utf8"));
+        return typeof parsed.fetchedAt === "string" && parsed.value !== undefined ? { fetchedAt: parsed.fetchedAt, value: parsed.value } : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function writeCache(file, value) {
+    try {
+        mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+        const temporary = `${file}.${process.pid}.tmp`;
+        writeFileSync(temporary, `${JSON.stringify({ fetchedAt: new Date().toISOString(), value })}\n`, { mode: 0o600 });
+        renameSync(temporary, file);
+    }
+    catch {
+    }
+}
+export async function getFromDoor(root, globals, projectId, pathAndQuery, timeoutMs) {
+    try {
+        const door = await resolveDoor(root, globals, projectId);
+        if (door.kind !== "door")
+            return null;
+        await assertCredentialOrigin(door.doorUrl);
+        const auth = await ensureAccessToken();
+        if (!auth)
+            return null;
+        const response = await fetch(`${door.doorUrl}/api/v2/projects/${encodeURIComponent(projectId)}${pathAndQuery}`, {
+            headers: { authorization: `Bearer ${auth.accessToken}` },
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        if (!response.ok)
+            return null;
+        const body = (await response.json());
+        return body.data === undefined ? null : { data: body.data, meta: body.meta ?? null };
+    }
+    catch {
+        return null;
+    }
+}
+export async function readBrief(root, globals, projectId, sessionId, refusalCount) {
+    const query = sessionId ? `?sessionId=${encodeURIComponent(sessionId)}` : "";
+    const answered = await getFromDoor(root, globals, projectId, `/sessions/brief${query}`, BRIEF_FETCH_TIMEOUT_MS);
+    const cacheFile = briefCachePath(projectId);
+    if (answered && answered.data && typeof answered.data === "object") {
+        const brief = answered.data;
+        writeCache(cacheFile, brief);
+        return { ...brief, refusalCount, offline: null, source: "server" };
+    }
+    const cached = readCache(cacheFile);
+    const since = cached?.fetchedAt ?? new Date().toISOString();
+    return {
+        ...(cached?.value ?? EMPTY_BRIEF),
+        refusalCount,
+        offline: { since, durationMs: Math.max(0, Date.now() - Date.parse(since)) },
+        source: "cache",
+    };
+}
+function obligationLine(item) {
+    const claim = typeof item.payload.claim === "string" ? ` — ${item.payload.claim}` : "";
+    return `- ${item.naturalKey}${claim}`;
+}
+export function renderBrief(brief, options = {}) {
+    const lines = ["NuStack session brief"];
+    if (brief.offline)
+        lines.push(`(offline since ${brief.offline.since}; this is the cached brief)`);
+    if (brief.previousHandover) {
+        const runtime = brief.previousHandover.runtime ? ` (${brief.previousHandover.runtime.replace(/_/g, " ")})` : "";
+        lines.push("", `Previous handover${runtime}, ${brief.previousHandover.createdAt}:`, brief.previousHandover.handover);
+    }
+    else {
+        lines.push("", "No previous handover.");
+    }
+    const items = brief.openObligations.items.slice(0, options.obligationLimit ?? brief.openObligations.items.length);
+    lines.push("", `Open obligations: ${brief.openObligations.total}`);
+    for (const item of items)
+        lines.push(obligationLine(item));
+    if (brief.openObligations.total > items.length)
+        lines.push(`… and ${brief.openObligations.total - items.length} more (nustack obligation list --plan <anchor>)`);
+    if (brief.refusalCount > 0)
+        lines.push("", `Refused record writes on this device: ${brief.refusalCount} (nustack records list).`);
+    return lines.join("\n");
+}
+export function renderHookOutput(brief) {
+    const tail = `\n\n${HANDOVER_LINE}`;
+    let body = renderBrief(brief, { obligationLimit: BRIEF_CONTEXT_OBLIGATIONS });
+    if (body.length + tail.length > BRIEF_CONTEXT_CAP)
+        body = `${body.slice(0, BRIEF_CONTEXT_CAP - tail.length - 1)}…`;
+    return JSON.stringify({ hookSpecificOutput: { hookEventName: "SessionStart", additionalContext: `${body}${tail}` } });
+}