@nurix/nustack 0.10.0-dev.18 → 0.10.0-dev.19

package/dist/commands/logscope.js

@@ -0,0 +1,55 @@
+import { answerLogscope, listLogscopeFunctions } from "../lib/logs/answer.js";
+import { loadLogscope } from "../lib/logs/library.js";
+import { allowSources, forgetCorpusCommand, indexLogs, listAllowed, listCorpora, pruneCorpora, revokeSources, } from "../lib/logs/lifecycle.js";
+export function logscopeArgv(rawArgv) {
+    const args = rawArgv.slice(2);
+    const at = args.indexOf("logscope");
+    return at === -1 ? [] : args.slice(at + 1);
+}
+const VALUED = ["--root", "--corpus", "--budget", "--retain", "--since", "--until", "--revision", "--note"];
+const BARE = ["--json", "--examples", "--no-redact", "--dry-run"];
+export function functionArgv(argv, fn) {
+    const valued = fn !== undefined && fn.args["limit"] !== undefined ? VALUED : [...VALUED, "--limit"];
+    const out = [];
+    for (let i = 0; i < argv.length; i++) {
+        const token = argv[i] ?? "";
+        if (valued.includes(token)) {
+            i++;
+            continue;
+        }
+        if (valued.some((flag) => token.startsWith(`${flag}=`)))
+            continue;
+        if (BARE.includes(token))
+            continue;
+        out.push(token);
+    }
+    return out;
+}
+function positionals(argv) {
+    return functionArgv(argv)
+        .slice(1)
+        .filter((token) => !token.startsWith("--"));
+}
+export async function runLogscope(rawArgv, options, cwd = process.cwd()) {
+    const argv = logscopeArgv(rawArgv);
+    const fn = argv.find((token) => !token.startsWith("--"));
+    if (fn === undefined || fn === "functions")
+        return listLogscopeFunctions(options);
+    if (fn === "index")
+        return indexLogs(positionals(argv), options, cwd);
+    if (fn === "corpora")
+        return listCorpora(options);
+    if (fn === "allow")
+        return allowSources(positionals(argv), options, cwd);
+    if (fn === "allowed")
+        return listAllowed(options, cwd);
+    if (fn === "revoke")
+        return revokeSources(positionals(argv), options, cwd);
+    if (fn === "prune")
+        return pruneCorpora(options, cwd);
+    if (fn === "forget")
+        return forgetCorpusCommand(positionals(argv)[0], options);
+    const library = await loadLogscope();
+    const rest = functionArgv(argv, library.findFn(fn));
+    return answerLogscope(fn, rest.slice(1), options, cwd);
+}

package/dist/commands/review.js

@@ -77,7 +77,16 @@ function readSubject(raw) {
         type: "tool_permission",
         toolName,
         displayName,
-        toolInput: row.toolInput ?? null,
+        ...(typeof row.target === "string" || row.target === null ? { target: row.target } : {}),
+        ...(typeof row.inputBytes === "number" && Number.isFinite(row.inputBytes)
+            ? { inputBytes: row.inputBytes }
+            : {}),
+        ...(Array.isArray(row.inputFields) && row.inputFields.every((field) => typeof field === "string")
+            ? { inputFields: row.inputFields }
+            : {}),
+        ...(typeof row.redactionVersion === "number" && Number.isFinite(row.redactionVersion)
+            ? { redactionVersion: row.redactionVersion }
+            : {}),
         ...(typeof row.description === "string" ? { description: row.description } : {}),
     };
 }
@@ -140,9 +149,9 @@ export function registerReviewCommands(reviewCommand, getGlobalOptions) {
         .action(async (options) => runReviewCheck(options, getGlobalOptions()));
     reviewCommand
         .command("mirror")
-        .description("Reflect a lane's permission prompt, or its answer, into the Review pane")
-        .option("--session <laneId>", "the lane's session id")
-        .option("--project <id>", "the Project the lane's folder is bound to (required with --state open)")
+        .description("Reflect a session's permission prompt, or its answer, into the Review pane")
+        .option("--session <sessionId>", "the session's id")
+        .option("--project <id>", "the Project the session's folder is bound to (required with --state open)")
         .option("--state <state>", "open or answered")
         .option("--subject <json>", "the tool-permission subject, as JSON (required with --state open)")
         .option("--verdict <verdict>", "allow or deny (required with --state answered)")

package/dist/commands/sessions.js

@@ -1,9 +1,20 @@
 import { readFile } from "node:fs/promises";
 import { ensureAccessToken } from "../lib/auth_grant.js";
 import { resolveNuStackUrl } from "../lib/nustack_client.js";
-import { makeSessionsClient } from "../lib/sessions/client.js";
+import { makeSessionsClient, sessionsClientFromEnv } from "../lib/sessions/client.js";
 import { recordOutsideSessions, } from "../lib/sessions/outsideSessions.js";
+import { SessionSupervisor } from "../lib/session-engine/supervisor.js";
 import { printJsonSuccess } from "../lib/json_output.js";
+export async function runSessionsServe(engineVersion) {
+    const supervisor = new SessionSupervisor({
+        input: process.stdin,
+        output: process.stdout,
+        engineVersion,
+        sessions: sessionsClientFromEnv(process.env),
+    });
+    await supervisor.run();
+    process.exit(0);
+}
 async function readScanArgument(raw) {
     const body = raw.startsWith("@") ? await readFile(raw.slice(1), "utf8") : raw;
     return JSON.parse(body);
@@ -46,6 +57,10 @@ export async function runSessionsRecord(options, globals) {
     if (!options.scan)
         return report("sessions record", EMPTY, json, "no scan payload");
     const payload = (await readScanArgument(options.scan).catch(() => null));
+    if (payload && "laneSessionIds" in payload) {
+        process.stderr.write("sessions record: this NuStack desktop is older than this CLI: it sent laneSessionIds, which is now engineSessionIds. Update both.\n");
+        process.exit(1);
+    }
     const transcripts = readTranscripts(payload?.sessions);
     if (transcripts.length === 0)
         return report("sessions record", EMPTY, json, "nothing to record");
@@ -54,8 +69,8 @@ export async function runSessionsRecord(options, globals) {
         return report("sessions record", EMPTY, json, "signed out");
     const summary = await recordOutsideSessions(makeSessionsClient(baseUrl, deviceAuth.accessToken), {
         transcripts,
-        laneSessionIds: Array.isArray(payload?.laneSessionIds)
-            ? payload.laneSessionIds.filter((id) => typeof id === "string")
+        engineSessionIds: Array.isArray(payload?.engineSessionIds)
+            ? payload.engineSessionIds.filter((id) => typeof id === "string")
             : [],
     });
     report("sessions record", summary, json);

package/dist/index.js

@@ -9,6 +9,7 @@ import { runSync } from "./commands/sync.js";
 import { runDescribe } from "./commands/describe.js";
 import { runValidate } from "./commands/validate.js";
 import { runGraph } from "./commands/graph.js";
+import { runLogscope } from "./commands/logscope.js";
 import { runDoctor } from "./commands/doctor.js";
 import { runTokenCreate, runTokenList, runTokenRevoke } from "./commands/token.js";
 import { runOpen } from "./commands/open.js";
@@ -23,8 +24,7 @@ import { runOrganizationList, runOrganizationCreate, runOrganizationUse } from "
 import { runDocsList, runDocsShow, runDocsStatus } from "./commands/docs.js";
 import { runHandoffList, runHandoffShow } from "./commands/handoff.js";
 import { runToolkitStatus, runToolkitReconcile } from "./commands/toolkit.js";
-import { runLaneServe } from "./commands/lane.js";
-import { runSessionsRecord } from "./commands/sessions.js";
+import { runSessionsRecord, runSessionsServe } from "./commands/sessions.js";
 import { registerReviewCommands } from "./commands/review.js";
 import { runAgentContext, runAgentHookInstall, runAgentHookRemove } from "./commands/agent.js";
 import { printJsonError } from "./lib/json_output.js";
@@ -96,6 +96,25 @@ program
     .allowUnknownOption()
     .allowExcessArguments()
     .action(async (_fn, _args, options) => runGraph(process.argv, options));
+program
+    .command("logscope [fn] [args...]")
+    .description("Log tracking: ask this machine's log corpus a question, or `index` / `corpora` / `allow` / `prune`")
+    .option("--root <dir>", "the project this command is about (default: the working tree's root)")
+    .option("--corpus <ref>", "a corpus id, or a path belonging to one")
+    .option("--budget <n>", "token ceiling for the answer; 0 means unbounded")
+    .option("--limit <n>", "rows requested — beats a default budget, never an explicit one")
+    .option("--retain <days>", "retention for `index`; 0 keeps the corpus until it is forgotten")
+    .option("--examples", "keep up to three exemplar log lines per template (off by default)")
+    .option("--no-redact", "store exemplars unredacted (loud, recorded on the corpus)")
+    .option("--since <ts>", "window start for container sources")
+    .option("--until <ts>", "window end for container sources")
+    .option("--revision <sha>", "the source revision these logs were written by")
+    .option("--note <text>", "a note recorded with an `allow` grant")
+    .option("--dry-run", "for `prune`: report what would be dropped and delete nothing")
+    .option("--json", "emit the versioned machine envelope with the answer as data")
+    .allowUnknownOption()
+    .allowExcessArguments()
+    .action(async (_fn, _args, options) => runLogscope(process.argv, options));
 program
     .command("doctor")
     .description("Run the full local diagnostics matrix (identity, repository, manifests, toolkit, telemetry, credentials)")
@@ -230,12 +249,13 @@ handoff
     .option("--targets", "list each target's path, operation, and base semantics")
     .option("--json", "emit the versioned machine envelope")
     .action(async (id, options) => runHandoffShow(id, options, program.opts()));
-const lane = program.command("lane").description("The desktop build room's lane engine");
-lane
+const sessions = program
+    .command("sessions")
+    .description("Sessions on this machine — the engine the desktop drives, and the record of what ran");
+sessions
     .command("serve")
-    .description("Run the long-lived lane supervisor: JSONL frames on stdin/stdout (used by the NuStack desktop)")
-    .action(async () => runLaneServe(version));
-const sessions = program.command("sessions").description("The session record over this machine's agent work");
+    .description("Run the long-lived session supervisor: JSONL frames on stdin/stdout (used by the NuStack desktop)")
+    .action(async () => runSessionsServe(version));
 sessions
     .command("record")
     .description("Record the sessions one desktop scan found in a bound folder (used by the NuStack desktop)")

package/dist/lib/logs/answer.js

@@ -0,0 +1,99 @@
+import { execFileSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { printJsonSuccess } from "../json_output.js";
+import { loadLogscope } from "./library.js";
+export class LogsNoRepository extends Error {
+    code = "LOGS_NO_REPOSITORY";
+    constructor(where) {
+        super(`not a git repository: ${where} — pass --root <path> or run inside a checkout`);
+        this.name = "LogsNoRepository";
+    }
+}
+export class LogsUnavailable extends Error {
+    code = "LOGS_UNAVAILABLE";
+    constructor(reason) {
+        super(reason);
+        this.name = "LogsUnavailable";
+    }
+}
+export class LogsRefused extends Error {
+    code = "LOGS_REFUSED";
+    constructor(reason) {
+        super(reason);
+        this.name = "LogsRefused";
+    }
+}
+export class LogsNotFound extends Error {
+    code = "LOGS_NOT_FOUND";
+    constructor(reason) {
+        super(reason);
+        this.name = "LogsNotFound";
+    }
+}
+export function resolveRoot(root, cwd) {
+    if (root !== undefined) {
+        const path = resolve(cwd, root);
+        if (!existsSync(path))
+            throw new LogsNoRepository(root);
+        return path;
+    }
+    return gitRoot(cwd);
+}
+function gitRoot(from) {
+    try {
+        return execFileSync("git", ["rev-parse", "--show-toplevel"], { cwd: from, stdio: ["ignore", "pipe", "ignore"] })
+            .toString("utf8")
+            .trim();
+    }
+    catch {
+        throw new LogsNoRepository(from);
+    }
+}
+export const progress = (line) => {
+    process.stderr.write(`${line}\n`);
+};
+export async function answerLogscope(fn, argv, options, cwd) {
+    const library = await loadLogscope();
+    const known = library.findFn(fn);
+    if (known === undefined) {
+        throw new LogsUnavailable(`unknown logscope function '${fn}' — run \`nustack logscope functions\` for the list`);
+    }
+    const args = library.parseArgs(known, argv);
+    if (known.args["root"] !== undefined && args["root"] === undefined) {
+        args["root"] = resolveRoot(options.root, cwd);
+    }
+    if (args["limit"] === undefined && options.limit !== undefined)
+        args["limit"] = Number(options.limit);
+    const limit = args["limit"];
+    const budget = options.budget !== undefined ? Number(options.budget) : limit !== undefined ? 0 : library.DEFAULT_BUDGET;
+    const result = library.dispatch({ fn: known.name, args, corpus: options.corpus, budget });
+    if (result.answer.unavailable !== undefined)
+        throw new LogsUnavailable(result.answer.unavailable);
+    if (options.json === true) {
+        printJsonSuccess(`logscope ${known.name}`, result.answer);
+        return;
+    }
+    console.log(result.rendered);
+}
+export async function listLogscopeFunctions(options) {
+    const library = await loadLogscope();
+    const budget = options.budget !== undefined ? Number(options.budget) : 0;
+    const result = library.dispatch({ fn: "functions", args: {}, budget });
+    if (options.json === true) {
+        printJsonSuccess("logscope functions", result.answer);
+        return;
+    }
+    console.log(result.rendered);
+    console.log([
+        "",
+        "lifecycle — `nustack logscope <verb>`",
+        "  allow <targets...>   grant a log source; nothing is read before this",
+        "  allowed              the grants covering this project",
+        "  revoke <targets...>  withdraw grants",
+        "  index <sources...>   ingest or refresh a corpus from granted sources",
+        "  corpora              every corpus indexed on this machine",
+        "  prune [--dry-run]    drop every corpus past its retention",
+        "  forget <id>          drop one corpus and its store",
+    ].join("\n"));
+}

package/dist/lib/logs/library.js

@@ -0,0 +1,19 @@
+export class LogsLibraryMissing extends Error {
+    code = "LOGS_LIBRARY_MISSING";
+    constructor() {
+        super("the log-tracking library is not installed with this nustack — install it beside the CLI (`npm i -g @nurix/logscope`) or run nustack from a checkout of the monorepo.");
+        this.name = "LogsLibraryMissing";
+    }
+}
+let cached = null;
+export async function loadLogscope() {
+    if (cached !== null)
+        return cached;
+    try {
+        cached = (await import("@nurix/logscope"));
+        return cached;
+    }
+    catch {
+        throw new LogsLibraryMissing();
+    }
+}

package/dist/lib/logs/lifecycle.js

@@ -0,0 +1,159 @@
+import { printJsonSuccess } from "../json_output.js";
+import { loadLogscope } from "./library.js";
+import { LogsNotFound, LogsRefused, progress, resolveRoot } from "./answer.js";
+function reportPruneToStderr(library) {
+    for (const record of library.prune()) {
+        progress(`pruned ${record.id} (retention ${library.retentionOf(record)} days, indexed ${record.indexedAt ?? "unknown"})`);
+    }
+}
+export async function indexLogs(targets, options, cwd) {
+    const library = await loadLogscope();
+    const root = resolveRoot(options.root, cwd);
+    const retentionDays = Number(options.retain ?? String(library.DEFAULT_RETENTION_DAYS));
+    if (!Number.isInteger(retentionDays) || retentionDays < 0) {
+        throw new LogsRefused("--retain takes a non-negative whole number of days");
+    }
+    reportPruneToStderr(library);
+    const outcome = await library.indexCorpus({
+        targets,
+        root,
+        since: options.since,
+        until: options.until,
+        revision: options.revision,
+        redact: options.redact !== false,
+        keepExamples: options.examples === true,
+        retentionDays,
+    });
+    if (!outcome.ok)
+        throw new LogsRefused(outcome.message);
+    if (options.json === true) {
+        printJsonSuccess("logscope index", {
+            id: outcome.id,
+            sources: outcome.sources,
+            events: outcome.events,
+            templates: outcome.templates,
+            ratio: outcome.ratio,
+            resumes: outcome.resumes,
+            retentionDays: outcome.retentionDays,
+            hasExamples: outcome.hasExamples,
+            expiresAt: outcome.expiresAt ?? null,
+            warning: outcome.warning ?? null,
+        });
+        return;
+    }
+    console.log([
+        `indexed ${outcome.id}`,
+        `  ${outcome.events} events -> ${outcome.templates} templates (ratio ${outcome.ratio.toFixed(4)})`,
+        `  sources      ${Object.entries(outcome.resumes).map(([path, resume]) => `${path} [${resume}]`).join(", ")}`,
+        `  retention    ${outcome.retentionDays === 0 ? "off (kept until forgotten)" : `${outcome.retentionDays} days (expires ${outcome.expiresAt ?? "unknown"})`}`,
+        `  examples     ${outcome.hasExamples ? "kept" : "not kept — drill and trace <id> cannot answer on this corpus"}`,
+        ...(outcome.warning === undefined ? [] : [`  WARNING: ${outcome.warning}`]),
+    ].join("\n"));
+}
+export async function listCorpora(options) {
+    const library = await loadLogscope();
+    reportPruneToStderr(library);
+    const corpora = library.readRegistry().map((record) => ({
+        id: record.id,
+        sources: record.sources,
+        events: record.events ?? 0,
+        templates: record.templates ?? 0,
+        indexedAt: record.indexedAt ?? null,
+        retentionDays: library.retentionOf(record),
+        expiresAt: library.expiresAt(record) ?? null,
+        hasExamples: record.hasExamples === true,
+    }));
+    if (options.json === true) {
+        printJsonSuccess("logscope corpora", { corpora });
+        return;
+    }
+    if (corpora.length === 0) {
+        console.log("no corpus has been indexed on this machine — run: nustack logscope index <sources...>");
+        return;
+    }
+    console.log(corpora
+        .map((corpus) => `${corpus.id}  ${corpus.events} events, ${corpus.templates} templates  (${corpus.sources.length} sources)  ` +
+        (corpus.retentionDays === 0
+            ? "retention off"
+            : `retention ${corpus.retentionDays} days, expires ${corpus.expiresAt ?? "unknown"}`))
+        .join("\n"));
+}
+export async function allowSources(targets, options, cwd) {
+    const library = await loadLogscope();
+    const root = resolveRoot(options.root, cwd);
+    const allowed = library.allow(root, targets, options.note).map((grant) => grant.path);
+    if (options.json === true) {
+        printJsonSuccess("logscope allow", { root, allowed });
+        return;
+    }
+    console.log(allowed.map((path) => `allowed ${path}`).join("\n"));
+}
+export async function listAllowed(options, cwd) {
+    const library = await loadLogscope();
+    const root = resolveRoot(options.root, cwd);
+    const grants = library.allowedFor(root);
+    if (options.json === true) {
+        printJsonSuccess("logscope allowed", { root, grants });
+        return;
+    }
+    if (grants.length === 0) {
+        console.log(`no source is allowed for ${root} — run: nustack logscope allow <path...>`);
+        return;
+    }
+    console.log(grants
+        .map((grant) => `${grant.path}  granted ${grant.grantedAt}${grant.note === undefined ? "" : `  ${grant.note}`}`)
+        .join("\n"));
+}
+export async function revokeSources(targets, options, cwd) {
+    const library = await loadLogscope();
+    const root = resolveRoot(options.root, cwd);
+    const revoked = library.revoke(root, targets);
+    if (revoked === 0)
+        throw new LogsNotFound(`no grant under ${root} names ${targets.join(", ")}`);
+    if (options.json === true) {
+        printJsonSuccess("logscope revoke", { root, revoked });
+        return;
+    }
+    console.log(`revoked ${revoked} grant(s)`);
+}
+export async function pruneCorpora(options, cwd) {
+    const library = await loadLogscope();
+    resolveRoot(options.root, cwd);
+    const dryRun = options.dryRun === true;
+    const now = new Date();
+    const candidates = dryRun
+        ? library.readRegistry().filter((record) => {
+            const at = library.expiresAt(record);
+            return at !== null && at !== undefined && new Date(at).getTime() <= now.getTime();
+        })
+        : library.prune();
+    const pruned = candidates.map((record) => ({
+        id: record.id,
+        retentionDays: library.retentionOf(record),
+        indexedAt: record.indexedAt ?? null,
+    }));
+    if (options.json === true) {
+        printJsonSuccess("logscope prune", { dryRun, pruned });
+        return;
+    }
+    if (pruned.length === 0) {
+        console.log("nothing to prune");
+        return;
+    }
+    console.log(pruned
+        .map((record) => `${dryRun ? "would prune" : "pruned"} ${record.id} (retention ${record.retentionDays} days, indexed ${record.indexedAt ?? "unknown"})`)
+        .join("\n"));
+}
+export async function forgetCorpusCommand(ref, options) {
+    const library = await loadLogscope();
+    if (ref === undefined)
+        throw new LogsNotFound("name the corpus to forget — run: nustack logscope corpora");
+    const forgot = library.forgetCorpus(ref);
+    if (forgot === undefined)
+        throw new LogsNotFound(`no corpus matches ${ref}`);
+    if (options.json === true) {
+        printJsonSuccess("logscope forget", { forgot });
+        return;
+    }
+    console.log(`forgot ${forgot}`);
+}

package/dist/lib/{lanes → session-engine}/claudeAdapter.js

@@ -1,6 +1,6 @@
 import { spawn } from "node:child_process";
 import { createInterface } from "node:readline";
-export function claudeLaneArgs(permissionMode, resumeSessionId) {
+export function claudeSessionArgs(permissionMode, resumeSessionId) {
     const args = [
         "-p",
         "--input-format",
@@ -20,7 +20,7 @@ export function claudeLaneArgs(permissionMode, resumeSessionId) {
 }
 const DENY_MESSAGE = "Denied by the user in NuStack desktop.";
 const STOP_KILL_GRACE_MS = 3_000;
-export class ClaudeLane {
+export class ClaudeSession {
     child;
     pendingApprovals = new Map();
     interruptSeq = 0;
@@ -30,7 +30,7 @@ export class ClaudeLane {
     constructor(options) {
         this.options = options;
         const spawnImpl = options.spawnImpl ?? spawn;
-        this.child = spawnImpl(options.claudeBin ?? "claude", claudeLaneArgs(options.permissionMode, options.resumeSessionId), {
+        this.child = spawnImpl(options.claudeBin ?? "claude", claudeSessionArgs(options.permissionMode, options.resumeSessionId), {
             cwd: options.cwd,
             env: options.env ?? process.env,
             stdio: ["pipe", "pipe", "pipe"],

package/dist/lib/{lanes → session-engine}/frames.js

@@ -1,10 +1,10 @@
-export const FRAME_VERSION = 1;
+export const FRAME_VERSION = 2;
 const INBOUND_TYPES = new Set([
-    "lane.open",
-    "lane.turn",
-    "lane.approval",
-    "lane.interrupt",
-    "lane.close",
+    "session.open",
+    "session.turn",
+    "session.approval",
+    "session.interrupt",
+    "session.close",
     "engine.shutdown",
 ]);
 export function parseInboundFrame(line) {
@@ -32,37 +32,37 @@ export function parseInboundFrame(line) {
     switch (type) {
         case "engine.shutdown":
             return { ok: true, frame: { v: FRAME_VERSION, type } };
-        case "lane.open": {
-            const laneId = requireString("laneId");
+        case "session.open": {
+            const sessionId = requireString("sessionId");
             const projectPath = requireString("projectPath");
-            if (!laneId || !projectPath)
-                return { ok: false, error: { code: "BAD_FRAME", name: type, message: "lane.open requires laneId and projectPath" } };
+            if (!sessionId || !projectPath)
+                return { ok: false, error: { code: "BAD_FRAME", name: type, message: "session.open requires sessionId and projectPath" } };
             const permissionMode = typeof frame.permissionMode === "string" ? frame.permissionMode : undefined;
             const isolated = frame.isolated === true ? true : undefined;
             const resumeSessionId = typeof frame.resumeSessionId === "string" && frame.resumeSessionId !== "" ? frame.resumeSessionId : undefined;
-            return { ok: true, frame: { v: FRAME_VERSION, type, laneId, projectPath, permissionMode, isolated, resumeSessionId } };
+            return { ok: true, frame: { v: FRAME_VERSION, type, sessionId, projectPath, permissionMode, isolated, resumeSessionId } };
         }
-        case "lane.turn": {
-            const laneId = requireString("laneId");
+        case "session.turn": {
+            const sessionId = requireString("sessionId");
             const text = typeof frame.text === "string" ? frame.text : null;
-            if (!laneId || text === null)
-                return { ok: false, error: { code: "BAD_FRAME", name: type, message: "lane.turn requires laneId and text" } };
-            return { ok: true, frame: { v: FRAME_VERSION, type, laneId, text } };
+            if (!sessionId || text === null)
+                return { ok: false, error: { code: "BAD_FRAME", name: type, message: "session.turn requires sessionId and text" } };
+            return { ok: true, frame: { v: FRAME_VERSION, type, sessionId, text } };
         }
-        case "lane.approval": {
-            const laneId = requireString("laneId");
+        case "session.approval": {
+            const sessionId = requireString("sessionId");
             const requestId = requireString("requestId");
             const verdict = frame.verdict === "allow" || frame.verdict === "deny" ? frame.verdict : null;
-            if (!laneId || !requestId || !verdict)
-                return { ok: false, error: { code: "BAD_FRAME", name: type, message: "lane.approval requires laneId, requestId, verdict" } };
-            return { ok: true, frame: { v: FRAME_VERSION, type, laneId, requestId, verdict } };
+            if (!sessionId || !requestId || !verdict)
+                return { ok: false, error: { code: "BAD_FRAME", name: type, message: "session.approval requires sessionId, requestId, verdict" } };
+            return { ok: true, frame: { v: FRAME_VERSION, type, sessionId, requestId, verdict } };
         }
-        case "lane.interrupt":
-        case "lane.close": {
-            const laneId = requireString("laneId");
-            if (!laneId)
-                return { ok: false, error: { code: "BAD_FRAME", name: type, message: `${type} requires laneId` } };
-            return { ok: true, frame: { v: FRAME_VERSION, type, laneId } };
+        case "session.interrupt":
+        case "session.close": {
+            const sessionId = requireString("sessionId");
+            if (!sessionId)
+                return { ok: false, error: { code: "BAD_FRAME", name: type, message: `${type} requires sessionId` } };
+            return { ok: true, frame: { v: FRAME_VERSION, type, sessionId } };
         }
         default:
             return { ok: false, error: { code: "UNKNOWN_FRAME", name: type, message: `unknown frame type: ${type}` } };

package/dist/lib/{lanes → session-engine}/supervisor.js

@@ -2,9 +2,9 @@ import { execFile } from "node:child_process";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { createInterface } from "node:readline";
-import { ClaudeLane } from "./claudeAdapter.js";
+import { ClaudeSession } from "./claudeAdapter.js";
 import { FRAME_VERSION, parseInboundFrame, serializeFrame, } from "./frames.js";
-import { createLaneWorktree, lanesHome } from "./worktree.js";
+import { createSessionWorktree, sessionsHome } from "./worktree.js";
 function defaultProbeClaude(env) {
     return new Promise((resolve) => {
         execFile("claude", ["--version"], { env, timeout: 5_000 }, (error, stdout) => {
@@ -15,11 +15,11 @@ function defaultProbeClaude(env) {
         });
     });
 }
-export class LaneSupervisor {
+export class SessionSupervisor {
     options;
     env;
-    lanes = new Map();
-    closingLanes = new Set();
+    sessions = new Map();
+    closingSessions = new Set();
     shuttingDown = false;
     resolveDone = null;
     lines = null;
@@ -31,14 +31,14 @@ export class LaneSupervisor {
     emit(frame) {
         this.options.output.write(serializeFrame(frame));
     }
-    status(laneId, status, message = null) {
-        this.emit({ v: FRAME_VERSION, type: "lane.status", laneId, status, message });
+    status(sessionId, status, message = null) {
+        this.emit({ v: FRAME_VERSION, type: "session.status", sessionId, status, message });
     }
-    error(laneId, code, message) {
-        this.emit({ v: FRAME_VERSION, type: "lane.error", laneId, code, message });
+    error(sessionId, code, message) {
+        this.emit({ v: FRAME_VERSION, type: "session.error", sessionId, code, message });
     }
     registryPath() {
-        return path.join(lanesHome(this.env), "registry.json");
+        return path.join(sessionsHome(this.env), "registry.json");
     }
     async boundProjectOf(projectPath) {
         try {
@@ -50,12 +50,12 @@ export class LaneSupervisor {
             return null;
         }
     }
-    async moveLaneSession(record, to) {
+    async moveSessionRow(record, to) {
         const client = this.options.sessions;
         if (!client || !record.projectId)
             return;
         try {
-            await client.transitionSession(record.projectId, record.laneId, to);
+            await client.transitionSession(record.projectId, record.sessionId, to);
         }
         catch {
         }
@@ -63,17 +63,17 @@ export class LaneSupervisor {
     async updateRegistry(mutate) {
         const run = async () => {
             const file = this.registryPath();
-            let lanes = [];
+            let sessions = [];
             try {
                 const parsed = JSON.parse(await readFile(file, "utf8"));
-                if (typeof parsed === "object" && parsed !== null && Array.isArray(parsed.lanes)) {
-                    lanes = parsed.lanes;
+                if (typeof parsed === "object" && parsed !== null && Array.isArray(parsed.sessions)) {
+                    sessions = parsed.sessions;
                 }
             }
             catch {
             }
             await mkdir(path.dirname(file), { recursive: true });
-            await writeFile(file, JSON.stringify({ v: 1, lanes: mutate(lanes) }, null, 2) + "\n", "utf8");
+            await writeFile(file, JSON.stringify({ v: 2, sessions: mutate(sessions) }, null, 2) + "\n", "utf8");
         };
         this.registryWrites = this.registryWrites.then(run, run);
         return this.registryWrites;
@@ -104,48 +104,48 @@ export class LaneSupervisor {
             case "engine.shutdown":
                 await this.shutdown();
                 return;
-            case "lane.open":
-                await this.openLane(frame.laneId, frame.projectPath, frame.permissionMode, frame.isolated, frame.resumeSessionId);
+            case "session.open":
+                await this.openSession(frame.sessionId, frame.projectPath, frame.permissionMode, frame.isolated, frame.resumeSessionId);
                 return;
-            case "lane.turn": {
-                const lane = this.lanes.get(frame.laneId);
-                if (!lane)
-                    return this.error(frame.laneId, "LANE_UNKNOWN", `no open lane ${frame.laneId}`);
-                lane.adapter.sendTurn(frame.text);
-                this.status(frame.laneId, "running");
+            case "session.turn": {
+                const session = this.sessions.get(frame.sessionId);
+                if (!session)
+                    return this.error(frame.sessionId, "SESSION_UNKNOWN", `no open session ${frame.sessionId}`);
+                session.adapter.sendTurn(frame.text);
+                this.status(frame.sessionId, "running");
                 return;
             }
-            case "lane.approval": {
-                const lane = this.lanes.get(frame.laneId);
-                if (!lane)
-                    return this.error(frame.laneId, "LANE_UNKNOWN", `no open lane ${frame.laneId}`);
-                lane.adapter.respondApproval(frame.requestId, frame.verdict);
+            case "session.approval": {
+                const session = this.sessions.get(frame.sessionId);
+                if (!session)
+                    return this.error(frame.sessionId, "SESSION_UNKNOWN", `no open session ${frame.sessionId}`);
+                session.adapter.respondApproval(frame.requestId, frame.verdict);
                 return;
             }
-            case "lane.interrupt": {
-                const lane = this.lanes.get(frame.laneId);
-                if (!lane)
-                    return this.error(frame.laneId, "LANE_UNKNOWN", `no open lane ${frame.laneId}`);
-                lane.adapter.interrupt();
+            case "session.interrupt": {
+                const session = this.sessions.get(frame.sessionId);
+                if (!session)
+                    return this.error(frame.sessionId, "SESSION_UNKNOWN", `no open session ${frame.sessionId}`);
+                session.adapter.interrupt();
                 return;
             }
-            case "lane.close": {
-                const lane = this.lanes.get(frame.laneId);
-                if (!lane)
-                    return this.error(frame.laneId, "LANE_UNKNOWN", `no open lane ${frame.laneId}`);
-                this.closingLanes.add(frame.laneId);
-                lane.adapter.stop();
+            case "session.close": {
+                const session = this.sessions.get(frame.sessionId);
+                if (!session)
+                    return this.error(frame.sessionId, "SESSION_UNKNOWN", `no open session ${frame.sessionId}`);
+                this.closingSessions.add(frame.sessionId);
+                session.adapter.stop();
                 return;
             }
         }
     }
-    async openLane(laneId, projectPath, permissionMode, isolated, resumeSessionId) {
-        if (this.lanes.has(laneId))
-            return this.error(laneId, "LANE_ALREADY_OPEN", `lane ${laneId} is already open`);
-        this.status(laneId, "starting");
-        const worktree = await createLaneWorktree(projectPath, laneId, this.env, isolated === true);
+    async openSession(sessionId, projectPath, permissionMode, isolated, resumeSessionId) {
+        if (this.sessions.has(sessionId))
+            return this.error(sessionId, "SESSION_ALREADY_OPEN", `session ${sessionId} is already open`);
+        this.status(sessionId, "starting");
+        const worktree = await createSessionWorktree(projectPath, sessionId, this.env, isolated === true);
         const record = {
-            laneId,
+            sessionId,
             projectPath,
             worktreePath: worktree.worktreePath,
             branch: worktree.branch,
@@ -153,6 +153,7 @@ export class LaneSupervisor {
             providerSessionId: null,
             createdAt: new Date().toISOString(),
             status: "open",
+            nustack: 1,
             projectId: await this.boundProjectOf(projectPath),
         };
         const adapterOptions = {
@@ -161,16 +162,16 @@ export class LaneSupervisor {
             resumeSessionId,
             env: this.env,
             onEvent: (event) => {
-                this.emit({ v: FRAME_VERSION, type: "lane.event", laneId, event });
+                this.emit({ v: FRAME_VERSION, type: "session.event", sessionId, event });
                 if (typeof event === "object" && event !== null && event.type === "result") {
-                    this.status(laneId, "ready");
+                    this.status(sessionId, "ready");
                 }
             },
             onApprovalRequest: (request) => {
                 this.emit({
                     v: FRAME_VERSION,
-                    type: "lane.approvalRequest",
-                    laneId,
+                    type: "session.approvalRequest",
+                    sessionId,
                     requestId: request.requestId,
                     toolName: request.toolName,
                     displayName: request.displayName,
@@ -178,43 +179,43 @@ export class LaneSupervisor {
                     description: request.description,
                 });
             },
-            onProtocolError: (code, message) => this.error(laneId, code, message),
-            onSessionId: (sessionId) => {
-                record.providerSessionId = sessionId;
-                void this.updateRegistry((lanes) => lanes.map((row) => (row.laneId === laneId ? { ...row, providerSessionId: sessionId } : row)));
+            onProtocolError: (code, message) => this.error(sessionId, code, message),
+            onSessionId: (vendorSessionId) => {
+                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, laneId, sessionId).catch(() => undefined);
+                    void client.setVendorSessionId(record.projectId, sessionId, vendorSessionId).catch(() => undefined);
                 }
             },
             onExit: (code) => {
-                const wasExpected = this.closingLanes.delete(laneId) || this.shuttingDown;
-                this.lanes.delete(laneId);
+                const wasExpected = this.closingSessions.delete(sessionId) || this.shuttingDown;
+                this.sessions.delete(sessionId);
                 if (!wasExpected)
-                    this.error(laneId, "ADAPTER_FAILED", `claude exited unexpectedly (code ${String(code)})`);
-                this.emit({ v: FRAME_VERSION, type: "lane.closed", laneId });
-                void this.updateRegistry((lanes) => lanes.map((row) => (row.laneId === laneId ? { ...row, status: "closed" } : row)));
-                void this.moveLaneSession(record, wasExpected ? "done" : "failed");
+                    this.error(sessionId, "ADAPTER_FAILED", `claude exited unexpectedly (code ${String(code)})`);
+                this.emit({ v: FRAME_VERSION, type: "session.closed", sessionId });
+                void this.updateRegistry((sessions) => sessions.map((row) => (row.sessionId === sessionId ? { ...row, status: "closed" } : row)));
+                void this.moveSessionRow(record, wasExpected ? "done" : "failed");
             },
         };
-        const create = this.options.createAdapter ?? ((opts) => new ClaudeLane(opts));
+        const create = this.options.createAdapter ?? ((opts) => new ClaudeSession(opts));
         let adapter;
         try {
             adapter = create(adapterOptions);
         }
         catch (error) {
-            return this.error(laneId, "ADAPTER_FAILED", error instanceof Error ? error.message : String(error));
+            return this.error(sessionId, "ADAPTER_FAILED", error instanceof Error ? error.message : String(error));
         }
-        this.lanes.set(laneId, { adapter, record });
-        await this.updateRegistry((lanes) => [...lanes.filter((row) => row.laneId !== laneId), record]);
+        this.sessions.set(sessionId, { adapter, record });
+        await this.updateRegistry((sessions) => [...sessions.filter((row) => row.sessionId !== sessionId), record]);
         if (this.options.sessions && record.projectId) {
             try {
                 await this.options.sessions.createSession(record.projectId, {
-                    id: laneId,
+                    id: sessionId,
                     startedBy: "person",
                     substrate: "device",
                     mode: "synchronous",
-                    origin: "inside",
+                    nustack: 1,
                     vendor: "claude_code",
                     renderer: "claude_transcript",
                     status: "created",
@@ -225,22 +226,22 @@ export class LaneSupervisor {
         }
         this.emit({
             v: FRAME_VERSION,
-            type: "lane.opened",
-            laneId,
+            type: "session.opened",
+            sessionId,
             projectPath,
             worktreePath: worktree.worktreePath,
             branch: worktree.branch,
             isolated: worktree.isolated,
         });
-        this.status(laneId, "ready");
+        this.status(sessionId, "ready");
     }
     async shutdown() {
         if (this.shuttingDown)
             return;
         this.shuttingDown = true;
-        for (const [, lane] of this.lanes)
-            lane.adapter.stop();
-        this.lanes.clear();
+        for (const [, session] of this.sessions)
+            session.adapter.stop();
+        this.sessions.clear();
         this.lines?.close();
         this.resolveDone?.();
     }

package/dist/lib/{lanes → session-engine}/worktree.js

@@ -2,12 +2,12 @@ import { execFile } from "node:child_process";
 import { mkdir } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-export const LANE_BRANCH_PREFIX = "nustack/lane-";
-export function lanesHome(env = process.env) {
-    const override = env.NUSTACK_LANES_HOME;
+export const ENGINE_SESSION_BRANCH_PREFIX = "nustack/session-";
+export function sessionsHome(env = process.env) {
+    const override = env.NUSTACK_SESSIONS_HOME;
     if (override && override !== "")
         return override;
-    return path.join(os.homedir(), ".nustack", "lanes");
+    return path.join(os.homedir(), ".nustack", "sessions");
 }
 function git(args, cwd) {
     return new Promise((resolve) => {
@@ -16,15 +16,15 @@ function git(args, cwd) {
         });
     });
 }
-export async function createLaneWorktree(projectPath, laneId, env = process.env, isolate = false) {
+export async function createSessionWorktree(projectPath, sessionId, env = process.env, isolate = false) {
     const inPlace = { worktreePath: projectPath, branch: null, isolated: false };
     if (!isolate)
         return inPlace;
     const isRepo = await git(["rev-parse", "--is-inside-work-tree"], projectPath);
     if (isRepo !== "true")
         return inPlace;
-    const branch = `${LANE_BRANCH_PREFIX}${laneId}`;
-    const worktreePath = path.join(lanesHome(env), "worktrees", laneId);
+    const branch = `${ENGINE_SESSION_BRANCH_PREFIX}${sessionId}`;
+    const worktreePath = path.join(sessionsHome(env), "worktrees", sessionId);
     await mkdir(path.dirname(worktreePath), { recursive: true });
     const added = await git(["worktree", "add", worktreePath, "-b", branch], projectPath);
     if (added === null)

package/dist/lib/sessions/outsideSessions.js

@@ -9,7 +9,7 @@ function vendorOf(provider) {
 const AT_REST = new Set(["done", "failed", "cancelled"]);
 export async function recordOutsideSessions(client, input) {
     const now = input.now ?? Date.now;
-    const laneIds = new Set((input.laneSessionIds ?? []).filter((id) => Boolean(id)));
+    const engineIds = new Set((input.engineSessionIds ?? []).filter((id) => Boolean(id)));
     const report = { created: 0, finished: 0, skipped: 0, failed: 0 };
     for (const transcript of input.transcripts) {
         if (!transcript.projectId) {
@@ -23,14 +23,14 @@ export async function recordOutsideSessions(client, input) {
         }
         const stale = now() - transcript.modifiedMs >= STOPPED_GROWING_MS;
         const vendorSessionId = transcript.vendorSessionId?.trim() || null;
-        const isLane = vendorSessionId !== null && laneIds.has(vendorSessionId);
+        const isEngineSession = vendorSessionId !== null && engineIds.has(vendorSessionId);
         try {
             const { created, session } = await client.createSession(transcript.projectId, {
                 id: transcript.sessionKey,
                 startedBy: "person",
                 substrate: "device",
                 mode: "synchronous",
-                origin: isLane ? "inside" : "outside",
+                nustack: isEngineSession ? 1 : 0,
                 vendor: kinds.vendor,
                 renderer: kinds.renderer,
                 status: stale ? "done" : "running",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nurix/nustack",
-  "version": "0.10.0-dev.18",
+  "version": "0.10.0-dev.19",
   "description": "The nustack CLI — bootstrap NuStack services into a repo via the NuStack discovery plane.",
   "type": "module",
   "private": false,
@@ -26,15 +26,16 @@
     "commander": "^14.0.0"
   },
   "optionalDependencies": {
-    "@nurix/codegraph": "0.2.1"
+    "@nurix/codegraph": "0.2.1",
+    "@nurix/logscope": "0.1.0"
   },
   "devDependencies": {
     "@ngneat/falso": "^8.0.2",
     "@types/node": "^22.19.20",
     "typescript": "^5.7.2",
     "vitest": "^4.1.11",
-    "@nurix/nustack.studio": "0.0.0",
-    "@nurix/nustack.ui": "0.0.0"
+    "@nurix/nustack.ui": "0.0.0",
+    "@nurix/nustack.studio": "0.0.0"
   },
   "publishConfig": {
     "access": "public"

package/dist/commands/lane.js

@@ -1,12 +0,0 @@
-import { LaneSupervisor } from "../lib/lanes/supervisor.js";
-import { sessionsClientFromEnv } from "../lib/sessions/client.js";
-export async function runLaneServe(engineVersion) {
-    const supervisor = new LaneSupervisor({
-        input: process.stdin,
-        output: process.stdout,
-        engineVersion,
-        sessions: sessionsClientFromEnv(process.env),
-    });
-    await supervisor.run();
-    process.exit(0);
-}