@nuvin/session 0.1.0-rc.5

package/dist/controller/index.js

@@ -0,0 +1,441 @@
+import {
+  resolveGrantDir
+} from "../chunk-UVJIG4DT.js";
+import {
+  asJsonObject,
+  createMessageStateFromMessages,
+  createSessionViewState,
+  isAutoApprovedTool,
+  reduceSessionEvent
+} from "../chunk-FR3R66RD.js";
+
+// src/controller/agent-channel.ts
+import { EventEmitter } from "events";
+var NO_DECIDER_DECISION = {
+  action: "reject",
+  reason: "UI is not ready to handle tool calls."
+};
+var AgentChannel = class {
+  emitter = new EventEmitter();
+  decider = null;
+  questionHandler = null;
+  // ---------- Agent-side (publishers) ----------
+  publishEvent(event, scope) {
+    this.emitter.emit("event", { event, scope });
+  }
+  publishSessionLoaded(loaded) {
+    this.emitter.emit("session-loaded", loaded);
+  }
+  requestToolDecision(request) {
+    if (!this.decider) {
+      return NO_DECIDER_DECISION;
+    }
+    return this.decider(request);
+  }
+  requestUserQuestion(request) {
+    if (!this.questionHandler) {
+      return Promise.reject(new Error("UI is not ready to handle user questions."));
+    }
+    return Promise.resolve(this.questionHandler(request));
+  }
+  // ---------- UI-side (subscribers) ----------
+  onEvent(listener) {
+    this.emitter.on("event", listener);
+    return () => {
+      this.emitter.off("event", listener);
+    };
+  }
+  onSessionLoaded(listener) {
+    this.emitter.on("session-loaded", listener);
+    return () => {
+      this.emitter.off("session-loaded", listener);
+    };
+  }
+  setToolDecider(decider) {
+    this.decider = decider;
+  }
+  setQuestionHandler(handler) {
+    this.questionHandler = handler;
+  }
+};
+
+// src/controller/session-controller.ts
+import {
+  isAbortError
+} from "@nuvin/agent-core/shared";
+var MAX_AUTO_COMPACTION_CHAIN = 10;
+function createSessionController(deps) {
+  const now = deps.now ?? Date.now;
+  const isAutoApproved = deps.isAutoApproved ?? isAutoApprovedTool;
+  const errorDetail = deps.errorDetail ?? ((error) => String(error));
+  const serverCommands = deps.serverCommands ?? [];
+  let compaction = deps.compaction;
+  let guardPrompt = deps.guardPrompt;
+  let autoCompactionChain = 0;
+  let state = createSessionViewState();
+  let seq = 0;
+  let sudoMode = false;
+  let abortController = null;
+  let questionCounter = 0;
+  const listeners = /* @__PURE__ */ new Set();
+  const approvalResolvers = /* @__PURE__ */ new Map();
+  const questionResolvers = /* @__PURE__ */ new Map();
+  const alwaysApproved = /* @__PURE__ */ new Set();
+  const queue = [];
+  let queueCounter = 0;
+  const deliveryQueue = [];
+  let draining = false;
+  const emit = (body) => {
+    seq += 1;
+    const event = Object.assign({}, body, { seq, at: now() });
+    state = reduceSessionEvent(state, event);
+    deliveryQueue.push(event);
+    if (draining) return;
+    draining = true;
+    try {
+      while (deliveryQueue.length > 0) {
+        const next = deliveryQueue.shift();
+        for (const listener of listeners) {
+          try {
+            listener(next);
+          } catch {
+          }
+        }
+      }
+    } finally {
+      draining = false;
+    }
+  };
+  const emitTurnStatus = (busy) => {
+    emit({
+      type: "turn-status",
+      busy,
+      queuedCount: queue.length,
+      queued: queue.map((q) => ({
+        id: q.id,
+        displayText: q.opts.displayText,
+        ...q.opts.attachmentLabels?.length ? { attachmentLabels: q.opts.attachmentLabels } : {}
+      }))
+    });
+  };
+  const unsubscribeEvents = deps.channel.onEvent(({ event, scope }) => {
+    if (event.type === "tool_call") return;
+    emit({ type: "agent-event", event, ...scope ? { scope } : {} });
+  });
+  const unsubscribeLoaded = deps.channel.onSessionLoaded((loaded) => {
+    abortController?.abort(new Error("Session loaded; the active turn was cancelled."));
+    rejectAllPending("Session loaded; pending interactions were cancelled.");
+    emit({
+      type: "state-reset",
+      // Loading a transcript replaces the live interaction state (messages,
+      // approvals, questions) but NOT the session identity: carry over the last
+      // published meta (model/cwd/persona/approvalMode) just like reset() does,
+      // else a resumed session reverts to the empty seed meta (no model name).
+      state: {
+        ...createSessionViewState(),
+        meta: state.meta,
+        messages: createMessageStateFromMessages(loaded.messages)
+      }
+    });
+  });
+  deps.channel.setToolDecider((request) => {
+    const { toolCall, agentId, parentToolCallId, dirAccess } = request;
+    const scope = parentToolCallId !== void 0 ? { agentId, parentToolCallId } : void 0;
+    const approvalKey = `${agentId}:${toolCall.name}`;
+    const auto = !dirAccess && (sudoMode || alwaysApproved.has(approvalKey) || isAutoApproved(toolCall.name));
+    if (dirAccess && sudoMode) {
+      emit({
+        type: "agent-event",
+        event: { type: "tool_call", toolCall },
+        toolStatus: "approved",
+        ...scope ? { scope } : {}
+      });
+      return { action: "run", grantDir: { dir: dirAccess.proposedDir, persist: false } };
+    }
+    if (auto) {
+      emit({
+        type: "agent-event",
+        event: { type: "tool_call", toolCall },
+        toolStatus: "approved",
+        ...scope ? { scope } : {}
+      });
+      return { action: "run" };
+    }
+    emit({
+      type: "agent-event",
+      event: { type: "tool_call", toolCall },
+      ...scope ? { scope } : {}
+    });
+    const nickname = nicknameFor(parentToolCallId);
+    const input = asJsonObject(toolCall.input);
+    const descriptor = {
+      agentId,
+      summary: findToolSummary(toolCall.id),
+      toolCallId: toolCall.id,
+      toolName: toolCall.name,
+      ...dirAccess !== void 0 ? { dirAccess } : {},
+      ...input !== void 0 ? { input } : {},
+      ...parentToolCallId !== void 0 ? { parentToolCallId } : {},
+      ...nickname !== void 0 ? { nickname } : {}
+    };
+    return new Promise((resolve) => {
+      approvalResolvers.set(toolCall.id, resolve);
+      emit({ type: "approval-requested", approval: descriptor });
+    });
+  });
+  deps.channel.setQuestionHandler((request) => {
+    questionCounter += 1;
+    const questionId = `question-${questionCounter}`;
+    return new Promise((resolve, reject) => {
+      questionResolvers.set(questionId, { resolve, reject });
+      emit({ type: "question-asked", question: { questionId, request } });
+    });
+  });
+  function findToolSummary(toolCallId) {
+    const messageId = state.messages.toolMessageIds[toolCallId];
+    const message = state.messages.messages.find((entry) => entry.id === messageId);
+    return message?.role === "tool" ? message.summary : "";
+  }
+  function nicknameFor(parentToolCallId) {
+    if (!parentToolCallId) return void 0;
+    const parentMessageId = state.messages.toolMessageIds[parentToolCallId];
+    const parentMessage = state.messages.messages.find((entry) => entry.id === parentMessageId);
+    if (parentMessage?.role !== "tool") return void 0;
+    const nickname = parentMessage.input?.nickname;
+    return typeof nickname === "string" ? nickname : void 0;
+  }
+  function findDescriptor(toolCallId) {
+    return [state.approval.active, ...state.approval.pending].find(
+      (entry) => entry?.toolCallId === toolCallId
+    );
+  }
+  function rejectAllPending(reason) {
+    for (const [toolCallId, resolve] of approvalResolvers) {
+      resolve({ action: "reject", reason });
+      emit({ type: "approval-settled", toolCallId, status: "rejected", by: "abort" });
+    }
+    approvalResolvers.clear();
+    for (const [questionId, { reject }] of questionResolvers) {
+      reject(new Error(reason));
+      emit({ type: "question-settled", questionId });
+    }
+    questionResolvers.clear();
+  }
+  function finalizeTurn(controller, reason) {
+    if (abortController !== controller) return;
+    abortController = null;
+    rejectAllPending(reason);
+    emitTurnStatus(false);
+    const next = queue.shift();
+    if (next) {
+      if (!next.opts.silent) {
+        emit({
+          type: "user-message",
+          text: next.opts.displayText,
+          ...next.opts.attachmentLabels?.length ? { attachmentLabels: next.opts.attachmentLabels } : {}
+        });
+      }
+      void runTurn(next.input, {});
+    }
+  }
+  async function runTurn(input, opts) {
+    const controller = new AbortController();
+    abortController = controller;
+    try {
+      emitTurnStatus(true);
+      if (!opts.systemInitiated) autoCompactionChain = 0;
+      compaction?.setEnabled(true);
+      let finalInput = input;
+      if (!opts.systemInitiated && guardPrompt) {
+        let guarded;
+        try {
+          guarded = await guardPrompt(input);
+        } catch (error) {
+          emit({ type: "error", message: `Turn failed: ${errorDetail(error)}` });
+          return;
+        }
+        if ("blocked" in guarded) {
+          emit({ type: "error", message: `Prompt blocked: ${guarded.blocked.reason}` });
+          return;
+        }
+        finalInput = guarded.prompt;
+      }
+      const compactionSend = (text) => runTurn(text, { systemInitiated: true });
+      const compactionIo = {
+        signal: controller.signal,
+        send: compactionSend,
+        onInfo: (message) => emit({ type: "info", message }),
+        onError: (message) => emit({ type: "error", message })
+      };
+      const runCompaction = async () => {
+        if (!compaction) return;
+        if (autoCompactionChain >= MAX_AUTO_COMPACTION_CHAIN) {
+          compaction.setEnabled(false);
+          emit({
+            type: "error",
+            message: `Auto-compaction stopped after ${MAX_AUTO_COMPACTION_CHAIN} consecutive compactions without getting under the context limit. Send a new message or use /compact to continue.`
+          });
+          return;
+        }
+        autoCompactionChain += 1;
+        await compaction.run(compactionIo);
+      };
+      try {
+        await deps.agent.send(finalInput, { streaming: true, signal: controller.signal });
+        if (compaction && !controller.signal.aborted) {
+          if (compaction.consumePendingAction() === "compact") {
+            await runCompaction();
+          }
+        }
+      } catch (error) {
+        try {
+          const recovered = compaction ? compaction.messagesFromError(error) : null;
+          if (recovered) {
+            deps.agent.messages = recovered;
+            await runCompaction();
+          } else if (!controller.signal.aborted && !isAbortError(error)) {
+            emit({ type: "error", message: `Turn failed: ${errorDetail(error)}` });
+          }
+        } catch (recoveryError) {
+          emit({ type: "error", message: `Turn failed: ${errorDetail(recoveryError)}` });
+        }
+      }
+    } finally {
+      finalizeTurn(controller, "Turn ended before pending interactions could be resolved.");
+    }
+  }
+  return {
+    abort() {
+      queue.length = 0;
+      abortController?.abort(new Error("User aborted the current turn."));
+    },
+    attachHostHooks(hooks) {
+      if (hooks.compaction) compaction = hooks.compaction;
+      if (hooks.guardPrompt) guardPrompt = hooks.guardPrompt;
+    },
+    answerQuestion(questionId, answers) {
+      const entry = questionResolvers.get(questionId);
+      if (!entry) return false;
+      questionResolvers.delete(questionId);
+      entry.resolve(answers);
+      emit({ type: "question-settled", questionId });
+      return true;
+    },
+    appendError(message) {
+      emit({ type: "error", message });
+    },
+    appendInfo(message) {
+      emit({ type: "info", message });
+    },
+    close() {
+      abortController?.abort(new Error("Session closed."));
+      rejectAllPending("Session closed.");
+      unsubscribeEvents();
+      unsubscribeLoaded();
+      deps.channel.setToolDecider(null);
+      deps.channel.setQuestionHandler(null);
+      listeners.clear();
+    },
+    dequeue(queuedId) {
+      const index = queue.findIndex((q) => q.id === queuedId);
+      if (index === -1) return false;
+      queue.splice(index, 1);
+      emitTurnStatus(abortController !== null);
+      return true;
+    },
+    decideApproval(toolCallId, decision, comment, grantDir) {
+      const resolve = approvalResolvers.get(toolCallId);
+      if (!resolve) return false;
+      approvalResolvers.delete(toolCallId);
+      const descriptor = findDescriptor(toolCallId);
+      if (decision === "a" && descriptor && !descriptor.dirAccess) {
+        alwaysApproved.add(`${descriptor.agentId}:${descriptor.toolName}`);
+      }
+      const rejected = decision === "n";
+      if (rejected) {
+        const baseReason = `User rejected tool execution (${descriptor?.toolName ?? "unknown tool"})`;
+        resolve({ action: "reject", reason: comment ? `${baseReason}: ${comment}` : baseReason });
+      } else if (descriptor?.dirAccess) {
+        resolve({
+          action: "run",
+          grantDir: {
+            dir: resolveGrantDir(
+              descriptor.dirAccess.requestedPath,
+              descriptor.dirAccess.proposedDir,
+              grantDir
+            ),
+            persist: decision === "a"
+          }
+        });
+      } else {
+        resolve({ action: "run" });
+      }
+      emit({
+        type: "approval-settled",
+        toolCallId,
+        status: rejected ? "rejected" : "approved",
+        by: "client"
+      });
+      return true;
+    },
+    echoUserMessage(text, attachmentLabels) {
+      emit({
+        type: "user-message",
+        text,
+        ...attachmentLabels?.length ? { attachmentLabels } : {}
+      });
+    },
+    getSnapshot() {
+      return { seq, state, serverCommands };
+    },
+    onEvent(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    publishSessionMeta(meta) {
+      emit({ type: "session-meta", meta });
+    },
+    publishMetrics(snapshot) {
+      emit({ type: "metrics", snapshot });
+    },
+    publishAuthFlow(flow) {
+      emit({ type: "auth-flow", flow });
+    },
+    publishWorkflowProgress(runId, delta) {
+      emit({ type: "workflow-progress", runId, delta });
+    },
+    reset() {
+      queue.length = 0;
+      abortController?.abort(new Error("Session reset."));
+      rejectAllPending("Session reset; pending interactions were cancelled.");
+      alwaysApproved.clear();
+      sudoMode = false;
+      emit({
+        type: "state-reset",
+        state: { ...createSessionViewState(), meta: state.meta }
+      });
+    },
+    setSudoMode(value) {
+      sudoMode = value;
+    },
+    async submit(input, opts) {
+      if (abortController) {
+        queue.push({ id: `q-${++queueCounter}`, input, opts });
+        emitTurnStatus(true);
+        return;
+      }
+      if (!opts.silent) {
+        emit({
+          type: "user-message",
+          text: opts.displayText,
+          ...opts.attachmentLabels?.length ? { attachmentLabels: opts.attachmentLabels } : {}
+        });
+      }
+      await runTurn(input, {});
+    }
+  };
+}
+export {
+  AgentChannel,
+  createSessionController
+};

package/dist/controller/session-controller.d.ts

@@ -0,0 +1,147 @@
+import type { AgentMetricsSnapshot } from "@nuvin/agent-core/agent";
+import { type AgentInput, type AskUserAnswers, type Message } from "@nuvin/agent-core/shared";
+import type { McpAuthFlowState, ServerEvent, SessionMeta, SessionSnapshot, SlashCommandDescriptor, WorkflowProgressDelta } from "../protocol/types.ts";
+import type { AgentChannel } from "./agent-channel.ts";
+/** Subset of Agent the controller needs — structurally satisfied by @nuvin/agent-core Agent. */
+export type AgentLike = {
+    messages: Message[];
+    send(input: AgentInput, opts: {
+        streaming: boolean;
+        signal: AbortSignal;
+    }): Promise<unknown>;
+};
+export type GuardResult = {
+    blocked: {
+        reason: string;
+    };
+} | {
+    prompt: AgentInput;
+};
+/**
+ * Compaction hooks, adapted from packages/cli/src/lib/chat/context-compaction.ts
+ * by the runtime assembly. Optional: absent in tests and minimal setups.
+ */
+export type CompactionHooks = {
+    /** Called at turn start so monitor observers can be muted for system turns. */
+    setEnabled(enabled: boolean): void;
+    /** After a successful turn: the action the monitor decided on. */
+    consumePendingAction(): "compact" | "none" | "warn";
+    /** If `error` demands compaction, return the recoverable messages, else null. */
+    messagesFromError(error: unknown): Message[] | null;
+    /** Compact, then resume by calling `send` (re-enters runTurn system-initiated). */
+    run(opts: {
+        signal: AbortSignal;
+        send: (text: string) => Promise<void>;
+        onInfo: (message: string) => void;
+        onError: (message: string) => void;
+    }): Promise<void>;
+};
+export interface SessionControllerDeps {
+    agent: AgentLike;
+    channel: AgentChannel;
+    compaction?: CompactionHooks;
+    /** UserPromptSubmit hook gate; absent = no guarding (test/dev mode). */
+    guardPrompt?: (input: AgentInput) => Promise<GuardResult>;
+    /** Defaults to isAutoApprovedTool from ../state. */
+    isAutoApproved?: (toolName: string) => boolean;
+    /** Injectable clock for deterministic tests. Defaults to Date.now. */
+    now?: () => number;
+    /** Format an unknown error for the transcript. Defaults to String(error). */
+    errorDetail?: (error: unknown) => string;
+    /**
+     * Descriptors for server-executed slash commands, surfaced to clients via the
+     * attach snapshot for autocomplete. Defaults to an empty list.
+     */
+    serverCommands?: SlashCommandDescriptor[];
+}
+export type SubmitOptions = {
+    displayText: string;
+    attachmentLabels?: string[];
+    /**
+     * When true, submit emits no `user-message` event (slash-initiated turns
+     * already echoed their text). `displayText` may be `""` in that case.
+     */
+    silent?: boolean;
+};
+export interface SessionController {
+    abort(): void;
+    /**
+     * Attach runtime-scoped hooks the daemon's session host owns. The host is
+     * built after the controller (it needs the controller), so compaction +
+     * guardPrompt are wired in here once the single real host exists. Provided
+     * hooks replace any construction-time values; `undefined` fields are ignored.
+     * Bind exactly one host per controller — this is what keeps a single,
+     * controller-bound compaction monitor (no duplicate, uncontrolled monitor).
+     */
+    attachHostHooks(hooks: {
+        compaction?: CompactionHooks;
+        guardPrompt?: (input: AgentInput) => Promise<GuardResult>;
+    }): void;
+    /**
+     * Settle a pending question by id.
+     *
+     * Single-active-question is the current protocol invariant: when parallel
+     * sub-agents ask concurrently, only the latest question is surfaced as
+     * `question.active` in state. All resolvers survive in the internal map, so
+     * answering any questionId settles the matching ask correctly.
+     */
+    answerQuestion(questionId: string, answers: AskUserAnswers): boolean;
+    /** Emit an error line into the replicated transcript. */
+    appendError(message: string): void;
+    /** Emit an info line into the replicated transcript (slash output, system notices). */
+    appendInfo(message: string): void;
+    close(): void;
+    /**
+     * Cancel a queued (not-yet-running) submission by its `turn-status.queued` id.
+     * Returns true if an item was removed, false if the id was unknown (already
+     * drained or never existed) — a race-safe no-op the host still acks ok.
+     */
+    dequeue(queuedId: string): boolean;
+    decideApproval(toolCallId: string, decision: "a" | "n" | "y", comment?: string, grantDir?: string): boolean;
+    /** Echo a user-style message without starting a turn (slash commands echo their invocation). */
+    echoUserMessage(text: string, attachmentLabels?: string[]): void;
+    /**
+     * Returns the live internal state reference (NOT a deep copy). This is safe
+     * only because every reducer is copy-on-write: past snapshots are never
+     * mutated in place. Callers must treat the returned state as read-only.
+     */
+    getSnapshot(): SessionSnapshot;
+    onEvent(listener: (event: ServerEvent) => void): () => void;
+    /** Publish display metadata (model name, cwd, approval mode). Host calls on config changes. */
+    publishSessionMeta(meta: SessionMeta): void;
+    /**
+     * Publish a live agent-metrics snapshot (spec §4.3). The host throttles these
+     * to ~1/s during a turn; the controller just sequences + reduces them.
+     */
+    publishMetrics(snapshot: AgentMetricsSnapshot): void;
+    /**
+     * Publish an MCP OAuth login flow update (spec §10/§12). The host calls this
+     * from its `McpAuthController` subscription; the controller sequences +
+     * reduces it like any other event. `null` clears the client modal.
+     */
+    publishAuthFlow(flow: McpAuthFlowState): void;
+    /**
+     * Publish a workflow UI progress delta (spec §8.2/§13). The WorkflowManager
+     * is the sole caller. emit-only — sequences + reduces into
+     * `state.workflows[runId]`; NEVER calls submit, never touches agent messages.
+     */
+    publishWorkflowProgress(runId: string, delta: WorkflowProgressDelta): void;
+    /**
+     * Reset session state: abort any active turn, clear queued submissions,
+     * reject pending approvals/questions, clear alwaysApproved + sudo, and emit
+     * a state-reset with a fresh view state CARRYING OVER the last published
+     * meta. Runtime-side resets (sessionStore.startNewSession, agent system
+     * prompt, metrics) are the HOST's job — it calls those, then this.
+     */
+    reset(): void;
+    setSudoMode(value: boolean): void;
+    /**
+     * Submit user input. If no turn is active, the returned promise resolves
+     * when the turn completes. If a turn is already active, the submission is
+     * queued and the promise resolves at ENQUEUE time — remote transports should
+     * ack on acceptance and observe completion via `turn-status` events.
+     */
+    submit(input: AgentInput, opts: SubmitOptions): Promise<void>;
+}
+export declare function createSessionController(deps: SessionControllerDeps): SessionController;
+//# sourceMappingURL=session-controller.d.ts.map

package/dist/controller/session-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-controller.d.ts","sourceRoot":"","sources":["../../src/controller/session-controller.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AACpE,OAAO,EACL,KAAK,UAAU,EACf,KAAK,cAAc,EAEnB,KAAK,OAAO,EAEb,MAAM,0BAA0B,CAAC;AAElC,OAAO,KAAK,EAEV,gBAAgB,EAChB,WAAW,EAEX,WAAW,EACX,eAAe,EACf,sBAAsB,EACtB,qBAAqB,EACtB,MAAM,sBAAsB,CAAC;AAM9B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD,gGAAgG;AAChG,MAAM,MAAM,SAAS,GAAG;IACtB,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,IAAI,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE;QAAE,SAAS,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,WAAW,CAAA;KAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC9F,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IAAE,OAAO,EAAE;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,GAAG;IAAE,MAAM,EAAE,UAAU,CAAA;CAAE,CAAC;AAEnF;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,+EAA+E;IAC/E,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IACnC,kEAAkE;IAClE,oBAAoB,IAAI,SAAS,GAAG,MAAM,GAAG,MAAM,CAAC;IACpD,iFAAiF;IACjF,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,EAAE,GAAG,IAAI,CAAC;IACpD,mFAAmF;IACnF,GAAG,CAAC,IAAI,EAAE;QACR,MAAM,EAAE,WAAW,CAAC;QACpB,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;QACtC,MAAM,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;QAClC,OAAO,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;KACpC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACnB,CAAC;AAEF,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,SAAS,CAAC;IACjB,OAAO,EAAE,YAAY,CAAC;IACtB,UAAU,CAAC,EAAE,eAAe,CAAC;IAC7B,wEAAwE;IACxE,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC;IAC1D,oDAAoD;IACpD,cAAc,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC;IAC/C,sEAAsE;IACtE,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB,6EAA6E;IAC7E,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,MAAM,CAAC;IACzC;;;OAGG;IACH,cAAc,CAAC,EAAE,sBAAsB,EAAE,CAAC;CAC3C;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,WAAW,EAAE,MAAM,CAAC;IACpB,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC5B;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,MAAM,WAAW,iBAAiB;IAChC,KAAK,IAAI,IAAI,CAAC;IACd;;;;;;;OAOG;IACH,eAAe,CAAC,KAAK,EAAE;QACrB,UAAU,CAAC,EAAE,eAAe,CAAC;QAC7B,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC;KAC3D,GAAG,IAAI,CAAC;IACT;;;;;;;OAOG;IACH,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC;IACrE,yDAAyD;IACzD,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,uFAAuF;IACvF,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,KAAK,IAAI,IAAI,CAAC;IACd;;;;OAIG;IACH,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;IACnC,cAAc,CACZ,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,EACzB,OAAO,CAAC,EAAE,MAAM,EAChB,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC;IACX,gGAAgG;IAChG,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,gBAAgB,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IACjE;;;;OAIG;IACH,WAAW,IAAI,eAAe,CAAC;IAC/B,OAAO,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;IAC5D,+FAA+F;IAC/F,kBAAkB,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,CAAC;IAC5C;;;OAGG;IACH,cAAc,CAAC,QAAQ,EAAE,oBAAoB,GAAG,IAAI,CAAC;IACrD;;;;OAIG;IACH,eAAe,CAAC,IAAI,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAC9C;;;;OAIG;IACH,uBAAuB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,qBAAqB,GAAG,IAAI,CAAC;IAC3E;;;;;;OAMG;IACH,KAAK,IAAI,IAAI,CAAC;IACd,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;IAClC;;;;;OAKG;IACH,MAAM,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/D;AAYD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,qBAAqB,GAAG,iBAAiB,CAmetF"}

package/dist/controller/test-utils.d.ts

@@ -0,0 +1,15 @@
+import type { ServerEvent } from "../protocol/types.ts";
+import { AgentChannel } from "./agent-channel.ts";
+import type { SessionControllerDeps } from "./session-controller.ts";
+export declare function makeDeps(overrides?: Partial<SessionControllerDeps>): {
+    channel: AgentChannel;
+    deps: SessionControllerDeps;
+    send: import("vitest").Mock<(_input: unknown, _opts: {
+        streaming: boolean;
+        signal: AbortSignal;
+    }) => Promise<void>>;
+};
+export declare function collectEvents(controller: {
+    onEvent(l: (e: ServerEvent) => void): () => void;
+}): ServerEvent[];
+//# sourceMappingURL=test-utils.d.ts.map

package/dist/controller/test-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-utils.d.ts","sourceRoot":"","sources":["../../src/controller/test-utils.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAErE,wBAAgB,QAAQ,CAAC,SAAS,GAAE,OAAO,CAAC,qBAAqB,CAAM;;;yCAGpD,OAAO,SAAS;QAAE,SAAS,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,WAAW,CAAA;KAAE;EAa7E;AAED,wBAAgB,aAAa,CAAC,UAAU,EAAE;IAAE,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,WAAW,KAAK,IAAI,GAAG,MAAM,IAAI,CAAA;CAAE,iBAI7F"}

package/dist/grant/index.d.ts

@@ -0,0 +1,33 @@
+import type { GrantPayload } from "../protocol/types.ts";
+/** ±5 min clock-skew tolerance on expiry/issuedAt checks (relay spec §7). */
+export declare const DEFAULT_GRANT_SKEW_MS: number;
+/** base64 DER key pair: `publicKey` SPKI (daemon.yaml), `privateKey` PKCS#8 (server secret). */
+export type GrantKeyPair = {
+    publicKey: string;
+    privateKey: string;
+};
+export type GrantVerifyFailure = "daemon-mismatch" | "expired" | "malformed" | "not-yet-valid" | "signature";
+export type GrantVerifyResult = {
+    ok: true;
+    payload: GrantPayload;
+} | {
+    ok: false;
+    reason: GrantVerifyFailure;
+};
+export declare function generateGrantKeyPair(): GrantKeyPair;
+/** Mint the wire form of a grant. Server-side (and tests); daemons only verify. */
+export declare function signGrant(payload: GrantPayload, privateKeyBase64: string): string;
+/**
+ * Verify a grant (relay spec §7, daemon-side): signature valid → daemonId is
+ * mine → expiresAt in the future and issuedAt not absurdly in the future
+ * (±skew). Never throws — every failure maps to a reason the caller turns
+ * into the existing `rejected {reason:"auth"}` path. Signature is checked
+ * BEFORE the payload is parsed so unsigned bytes are never trusted.
+ */
+export declare function verifyGrant(grant: string, opts: {
+    publicKey: string;
+    daemonId: string;
+    now?: number;
+    skewMs?: number;
+}): GrantVerifyResult;
+//# sourceMappingURL=index.d.ts.map

package/dist/grant/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/grant/index.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD,6EAA6E;AAC7E,eAAO,MAAM,qBAAqB,QAAgB,CAAC;AAEnD,gGAAgG;AAChG,MAAM,MAAM,YAAY,GAAG;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC;AAErE,MAAM,MAAM,kBAAkB,GAC1B,iBAAiB,GACjB,SAAS,GACT,WAAW,GACX,eAAe,GACf,WAAW,CAAC;AAEhB,MAAM,MAAM,iBAAiB,GACzB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,YAAY,CAAA;CAAE,GACnC;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,kBAAkB,CAAA;CAAE,CAAC;AAE9C,wBAAgB,oBAAoB,IAAI,YAAY,CAMnD;AAED,mFAAmF;AACnF,wBAAgB,SAAS,CAAC,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,GAAG,MAAM,CASjF;AAcD;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAC3E,iBAAiB,CAuCnB"}

package/dist/grant/index.js

@@ -0,0 +1,12 @@
+import {
+  DEFAULT_GRANT_SKEW_MS,
+  generateGrantKeyPair,
+  signGrant,
+  verifyGrant
+} from "../chunk-3IPZO7LP.js";
+export {
+  DEFAULT_GRANT_SKEW_MS,
+  generateGrantKeyPair,
+  signGrant,
+  verifyGrant
+};

package/dist/protocol/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./types.ts";
+export * from "./version.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/protocol/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/protocol/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC"}

package/dist/protocol/index.js

@@ -0,0 +1,7 @@
+import "../chunk-DGC7JSCG.js";
+import {
+  PROTOCOL_VERSION
+} from "../chunk-7G3R25NS.js";
+export {
+  PROTOCOL_VERSION
+};