@hayasaka7/haya-pet 0.1.0

package/packages/session-core/src/summaries.js

@@ -0,0 +1,54 @@
+const STATUS_LABELS = Object.freeze({
+  idle: "Idle",
+  thinking: "Thinking",
+  running_tool: "Running tools",
+  editing_files: "Editing files",
+  waiting_user: "Waiting for you",
+  waiting_approval: "Waiting for approval",
+  reviewing: "Reviewing",
+  compacting: "Compacting context",
+  failed: "Failed",
+  success: "Done",
+  stale: "Stale",
+  exited: "Exited"
+});
+
+export function buildStatusLabel(state) {
+  return STATUS_LABELS[state] ?? humanize(state);
+}
+
+export function buildSessionSummary(session) {
+  if (session && typeof session.summary === "string" && session.summary.trim() !== "") {
+    return session.summary;
+  }
+
+  return buildStatusLabel(session?.state);
+}
+
+export function formatElapsed(ms) {
+  const totalSeconds = Math.max(0, Math.floor((Number.isFinite(ms) ? ms : 0) / 1000));
+
+  if (totalSeconds < 60) {
+    return `${totalSeconds}s`;
+  }
+
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+
+  if (minutes < 60) {
+    return `${minutes}m ${seconds}s`;
+  }
+
+  const hours = Math.floor(minutes / 60);
+  const remainderMinutes = minutes % 60;
+  return `${hours}h ${remainderMinutes}m`;
+}
+
+function humanize(value) {
+  if (typeof value !== "string" || value === "") {
+    return "Unknown";
+  }
+
+  const text = value.replace(/_/g, " ");
+  return text.charAt(0).toUpperCase() + text.slice(1);
+}

package/packages/session-core/test/bubble-linger.test.mjs

@@ -0,0 +1,96 @@
+import assert from "node:assert/strict";
+import { test } from "../../../test/harness.mjs";
+import { resolveVisibleBubbles, ENDED_STATES } from "../src/bubble-linger.js";
+
+function bubble(sessionId, state) {
+  return { sessionId, state };
+}
+
+test("ENDED_STATES covers the process-finished states", () => {
+  assert.ok(ENDED_STATES.has("exited"));
+  assert.ok(ENDED_STATES.has("success"));
+  assert.ok(ENDED_STATES.has("failed"));
+  assert.ok(!ENDED_STATES.has("idle"));
+  assert.ok(!ENDED_STATES.has("running_tool"));
+});
+
+test("keeps active (non-ended) bubbles visible with no linger tracking", () => {
+  const result = resolveVisibleBubbles({
+    bubbles: [bubble("a", "running_tool"), bubble("b", "idle")],
+    now: 1000
+  });
+  assert.deepEqual(result.visible.map((b) => b.sessionId), ["a", "b"]);
+  assert.deepEqual(result.lingerState, {});
+  assert.equal(result.nextWakeMs, undefined);
+});
+
+test("shows a freshly ended bubble and schedules its removal", () => {
+  const result = resolveVisibleBubbles({
+    bubbles: [bubble("a", "success")],
+    now: 1000,
+    lingerMs: 2000
+  });
+  assert.deepEqual(result.visible.map((b) => b.sessionId), ["a"]);
+  assert.equal(result.lingerState.a, 1000); // first seen ended at now
+  assert.equal(result.nextWakeMs, 2000);
+});
+
+test("keeps the ended bubble visible until the linger window elapses", () => {
+  const result = resolveVisibleBubbles({
+    bubbles: [bubble("a", "success")],
+    now: 2500,
+    lingerState: { a: 1000 },
+    lingerMs: 2000
+  });
+  assert.deepEqual(result.visible.map((b) => b.sessionId), ["a"]);
+  assert.equal(result.nextWakeMs, 500); // 2000 - (2500 - 1000)
+});
+
+test("hides the ended bubble once the linger window has passed", () => {
+  const result = resolveVisibleBubbles({
+    bubbles: [bubble("a", "failed")],
+    now: 3001,
+    lingerState: { a: 1000 },
+    lingerMs: 2000
+  });
+  assert.deepEqual(result.visible, []);
+  // still tracked (so it stays hidden if it reappears in later payloads)...
+  assert.equal(result.lingerState.a, 1000);
+  // ...but nothing left to wake up for.
+  assert.equal(result.nextWakeMs, undefined);
+});
+
+test("anchors the linger clock to the FIRST ended state, not later ones (success -> exited)", () => {
+  // success first seen at 1000; the later 'exited' message must not reset it.
+  const afterSuccess = resolveVisibleBubbles({ bubbles: [bubble("a", "success")], now: 1000, lingerMs: 2000 });
+  const afterExited = resolveVisibleBubbles({
+    bubbles: [bubble("a", "exited")],
+    now: 1500,
+    lingerState: afterSuccess.lingerState,
+    lingerMs: 2000
+  });
+  assert.equal(afterExited.lingerState.a, 1000);
+  assert.equal(afterExited.nextWakeMs, 1500); // 2000 - (1500 - 1000)
+});
+
+test("drops linger tracking for sessions no longer present", () => {
+  const result = resolveVisibleBubbles({
+    bubbles: [bubble("b", "running_tool")],
+    now: 5000,
+    lingerState: { a: 1000 },
+    lingerMs: 2000
+  });
+  assert.deepEqual(result.visible.map((x) => x.sessionId), ["b"]);
+  assert.deepEqual(result.lingerState, {}); // 'a' is gone -> forgotten
+});
+
+test("reports the soonest wake among several ended bubbles", () => {
+  const result = resolveVisibleBubbles({
+    bubbles: [bubble("a", "success"), bubble("b", "failed")],
+    now: 1800,
+    lingerState: { a: 1000, b: 1500 },
+    lingerMs: 2000
+  });
+  // a: 2000-800=1200 remaining; b: 2000-300=1700 remaining -> soonest is 1200
+  assert.equal(result.nextWakeMs, 1200);
+});

package/packages/session-core/test/bubble-view.test.mjs

@@ -0,0 +1,79 @@
+import assert from "node:assert/strict";
+import { test } from "../../../test/harness.mjs";
+import { buildBubbleView, buildBubbleViews, resolveBubbleStatusKind } from "../src/bubble-view.js";
+
+const baseSession = {
+  sessionId: "sess_a",
+  clientId: "codex",
+  clientDisplayName: "Codex",
+  projectName: "netdisk-server",
+  state: "waiting_approval",
+  summary: "waiting for command approval",
+  startedAt: 1_000,
+  updatedAt: 5_000
+};
+
+test("builds a bubble view model with label, summary, action, and elapsed", () => {
+  const view = buildBubbleView(baseSession, 65_000);
+
+  assert.equal(view.sessionId, "sess_a");
+  assert.equal(view.clientId, "codex");
+  assert.equal(view.clientName, "Codex");
+  assert.equal(view.projectName, "netdisk-server");
+  assert.equal(view.state, "waiting_approval");
+  assert.equal(view.statusLabel, "Waiting for approval");
+  assert.equal(view.summary, "waiting for command approval");
+  assert.equal(view.petAction, "waiting");
+  assert.equal(view.elapsedMs, 64_000);
+  assert.equal(view.elapsedLabel, "1m 4s");
+});
+
+test("orders bubbles by session priority then recency", () => {
+  const sessions = [
+    { ...baseSession, sessionId: "sess_idle", state: "idle", updatedAt: 9_000 },
+    { ...baseSession, sessionId: "sess_wait", state: "waiting_approval", updatedAt: 4_000 },
+    { ...baseSession, sessionId: "sess_run", state: "running_tool", updatedAt: 8_000 }
+  ];
+
+  const views = buildBubbleViews(sessions, 10_000);
+  assert.deepEqual(views.map((view) => view.sessionId), ["sess_wait", "sess_run", "sess_idle"]);
+});
+
+test("marks the selected/pinned session", () => {
+  const views = buildBubbleViews([baseSession], 6_000, { selectedSessionId: "sess_a" });
+  assert.equal(views[0].selected, true);
+});
+
+test("resolves working states to the 'working' status kind (spinner)", () => {
+  for (const state of ["thinking", "running_tool", "editing_files", "reviewing", "compacting"]) {
+    assert.equal(resolveBubbleStatusKind(state), "working", state);
+  }
+});
+
+test("resolves attention states to the 'attention' status kind (yellow)", () => {
+  for (const state of ["waiting_user", "waiting_approval", "stale"]) {
+    assert.equal(resolveBubbleStatusKind(state), "attention", state);
+  }
+});
+
+test("resolves failure to the 'failed' status kind (red cross)", () => {
+  assert.equal(resolveBubbleStatusKind("failed"), "failed");
+});
+
+test("resolves idle/finished states to the 'done' status kind (check mark)", () => {
+  for (const state of ["idle", "success", "exited"]) {
+    assert.equal(resolveBubbleStatusKind(state), "done", state);
+  }
+});
+
+test("falls back to a neutral 'idle' kind for unknown states", () => {
+  assert.equal(resolveBubbleStatusKind("totally-unknown"), "idle");
+  assert.equal(resolveBubbleStatusKind(undefined), "idle");
+});
+
+test("exposes statusKind on the bubble view model", () => {
+  assert.equal(buildBubbleView({ ...baseSession, state: "running_tool" }, 6_000).statusKind, "working");
+  assert.equal(buildBubbleView({ ...baseSession, state: "waiting_approval" }, 6_000).statusKind, "attention");
+  assert.equal(buildBubbleView({ ...baseSession, state: "failed" }, 6_000).statusKind, "failed");
+  assert.equal(buildBubbleView({ ...baseSession, state: "idle" }, 6_000).statusKind, "done");
+});

package/packages/session-core/test/pet-state.test.mjs

@@ -0,0 +1,118 @@
+import assert from "node:assert/strict";
+import { test } from "../../../test/harness.mjs";
+import { resolveCompanionPetState } from "../src/pet-state.js";
+
+function bubble(sessionId, state) {
+  return { sessionId, state };
+}
+
+test("drives the stable action from the highest-priority active session", () => {
+  const result = resolveCompanionPetState({
+    bubbles: [bubble("a", "waiting_approval"), bubble("b", "idle")],
+    prioritySessionId: "a",
+    previousStates: {}
+  });
+  assert.equal(result.stableAction, "waiting");
+});
+
+test("returns idle when there are no active sessions", () => {
+  const result = resolveCompanionPetState({
+    bubbles: [bubble("a", "exited")],
+    prioritySessionId: "a",
+    previousStates: { a: "success" }
+  });
+  assert.equal(result.stableAction, "idle");
+});
+
+test("excludes finished sessions from the active bubble list", () => {
+  const result = resolveCompanionPetState({
+    bubbles: [bubble("a", "idle"), bubble("b", "exited"), bubble("c", "success")],
+    prioritySessionId: "a",
+    previousStates: {}
+  });
+  assert.deepEqual(result.activeBubbles.map((b) => b.sessionId), ["a"]);
+});
+
+test("fires a one-shot jump when a session transitions into success", () => {
+  const result = resolveCompanionPetState({
+    bubbles: [bubble("a", "success")],
+    prioritySessionId: "a",
+    previousStates: { a: "running_tool" }
+  });
+  assert.deepEqual(result.oneShots, ["jumping"]);
+});
+
+test("does not repeat the success one-shot once already seen", () => {
+  const result = resolveCompanionPetState({
+    bubbles: [bubble("a", "success")],
+    prioritySessionId: "a",
+    previousStates: { a: "success" }
+  });
+  assert.deepEqual(result.oneShots, []);
+});
+
+test("failure is a one-shot reaction, not a sticky stable action", () => {
+  const result = resolveCompanionPetState({
+    bubbles: [bubble("a", "failed")],
+    prioritySessionId: "a",
+    previousStates: { a: "running_tool" }
+  });
+  // plays the failed reaction once...
+  assert.deepEqual(result.oneShots, ["failed"]);
+  // ...but does not pin the pet on a looping "failed" stable action
+  assert.equal(result.stableAction, "idle");
+});
+
+test("does not repeat the failed reaction while it stays failed", () => {
+  const result = resolveCompanionPetState({
+    bubbles: [bubble("a", "failed")],
+    prioritySessionId: "a",
+    previousStates: { a: "failed" }
+  });
+  assert.deepEqual(result.oneShots, []);
+  assert.equal(result.stableAction, "idle");
+});
+
+test("a failed session still yields to active work for the stable action", () => {
+  const result = resolveCompanionPetState({
+    bubbles: [bubble("a", "failed"), bubble("b", "running_tool")],
+    prioritySessionId: "a",
+    previousStates: { a: "failed", b: "running_tool" }
+  });
+  assert.equal(result.stableAction, "running");
+});
+
+test("celebrates with a one-shot jump when a working turn finishes (working -> idle)", () => {
+  const result = resolveCompanionPetState({
+    bubbles: [bubble("a", "idle")],
+    prioritySessionId: "a",
+    previousStates: { a: "running_tool" }
+  });
+  assert.deepEqual(result.oneShots, ["jumping"]);
+  assert.equal(result.stableAction, "idle");
+});
+
+test("no finished reaction when idle was not preceded by active work", () => {
+  assert.deepEqual(
+    resolveCompanionPetState({ bubbles: [bubble("a", "idle")], prioritySessionId: "a", previousStates: { a: "idle" } }).oneShots,
+    []
+  );
+  assert.deepEqual(
+    resolveCompanionPetState({ bubbles: [bubble("a", "idle")], prioritySessionId: "a", previousStates: {} }).oneShots,
+    []
+  );
+  // waiting -> idle is not "finished work"
+  assert.deepEqual(
+    resolveCompanionPetState({ bubbles: [bubble("a", "idle")], prioritySessionId: "a", previousStates: { a: "waiting_user" } }).oneShots,
+    []
+  );
+});
+
+test("returns the next state map for the following update", () => {
+  const result = resolveCompanionPetState({
+    bubbles: [bubble("a", "idle"), bubble("b", "exited")],
+    prioritySessionId: "a",
+    previousStates: {}
+  });
+  assert.deepEqual(result.nextStates, { a: "idle", b: "exited" });
+});

package/packages/session-core/test/priority.test.mjs

@@ -0,0 +1,53 @@
+import assert from "node:assert/strict";
+import { test } from "../../../test/harness.mjs";
+import { selectPrioritySession } from "../src/priority.js";
+
+function session(sessionId, state, updatedAt) {
+  return {
+    sessionId,
+    clientId: "generic",
+    clientDisplayName: "Generic",
+    pid: 1000 + updatedAt,
+    cwd: "D:\\Work\\project",
+    projectName: "project",
+    state,
+    source: "wrapper",
+    startedAt: 1,
+    updatedAt
+  };
+}
+
+test("returns undefined when there are no sessions", () => {
+  assert.equal(selectPrioritySession([]), undefined);
+});
+
+test("uses the pinned session before automatic urgency", () => {
+  const selected = selectPrioritySession([
+    session("codex", "running_tool", 30),
+    session("claude", "waiting_approval", 20)
+  ], { pinnedSessionId: "codex" });
+
+  assert.equal(selected.sessionId, "codex");
+});
+
+test("prioritizes urgent waiting states before active work and recency", () => {
+  const selected = selectPrioritySession([
+    session("idle", "idle", 100),
+    session("thinking", "thinking", 90),
+    session("running", "running_tool", 80),
+    session("failed", "failed", 70),
+    session("waiting-user", "waiting_user", 60),
+    session("approval", "waiting_approval", 50)
+  ]);
+
+  assert.equal(selected.sessionId, "approval");
+});
+
+test("breaks ties within a priority group by most recent update", () => {
+  const selected = selectPrioritySession([
+    session("older", "running_tool", 20),
+    session("newer", "editing_files", 40)
+  ]);
+
+  assert.equal(selected.sessionId, "newer");
+});

package/packages/session-core/test/registry.test.mjs

@@ -0,0 +1,161 @@
+import assert from "node:assert/strict";
+import { test } from "../../../test/harness.mjs";
+import { createSessionRegistry } from "../src/registry.js";
+
+function registerMessage(sessionId, overrides = {}) {
+  return {
+    type: "register",
+    sessionId,
+    clientId: "generic",
+    clientDisplayName: "Generic",
+    pid: 12345,
+    cwd: "D:\\Work\\project",
+    projectName: "project",
+    startedAt: 1000,
+    ...overrides
+  };
+}
+
+test("registers sessions from protocol messages", () => {
+  const registry = createSessionRegistry();
+
+  registry.applyMessage(registerMessage("sess_a"));
+
+  assert.deepEqual(registry.listSessions().map((session) => session.sessionId), ["sess_a"]);
+  assert.deepEqual(registry.getSession("sess_a"), {
+    sessionId: "sess_a",
+    clientId: "generic",
+    clientDisplayName: "Generic",
+    pid: 12345,
+    terminalPid: undefined,
+    cwd: "D:\\Work\\project",
+    projectName: "project",
+    state: "idle",
+    source: "wrapper",
+    startedAt: 1000,
+    updatedAt: 1000
+  });
+});
+
+test("applies state and heartbeat messages without losing session metadata", () => {
+  const registry = createSessionRegistry();
+
+  registry.applyMessage(registerMessage("sess_a"));
+  registry.applyMessage({
+    type: "state",
+    sessionId: "sess_a",
+    state: "waiting_approval",
+    summary: "waiting for command approval",
+    confidence: 0.9,
+    source: "pty_output",
+    updatedAt: 1200
+  });
+  registry.applyMessage({
+    type: "heartbeat",
+    sessionId: "sess_a",
+    updatedAt: 1300
+  });
+
+  const session = registry.getSession("sess_a");
+  assert.equal(session.state, "waiting_approval");
+  assert.equal(session.summary, "waiting for command approval");
+  assert.equal(session.confidence, 0.9);
+  assert.equal(session.source, "pty_output");
+  assert.equal(session.updatedAt, 1300);
+  assert.equal(session.projectName, "project");
+});
+
+test("unregister marks sessions as exited and preserves exit details", () => {
+  const registry = createSessionRegistry();
+
+  registry.applyMessage(registerMessage("sess_a"));
+  registry.applyMessage({
+    type: "unregister",
+    sessionId: "sess_a",
+    exitCode: 7,
+    finishedAt: 1400
+  });
+
+  assert.equal(registry.getSession("sess_a").state, "exited");
+  assert.equal(registry.getSession("sess_a").exitCode, 7);
+  assert.equal(registry.getSession("sess_a").finishedAt, 1400);
+  assert.equal(registry.getSession("sess_a").updatedAt, 1400);
+});
+
+test("selects the priority session from registered sessions", () => {
+  const registry = createSessionRegistry();
+
+  registry.applyMessage(registerMessage("codex", { startedAt: 1000 }));
+  registry.applyMessage(registerMessage("claude", { startedAt: 1100 }));
+  registry.applyMessage({
+    type: "state",
+    sessionId: "codex",
+    state: "running_tool",
+    confidence: 0.7,
+    source: "wrapper",
+    updatedAt: 1200
+  });
+  registry.applyMessage({
+    type: "state",
+    sessionId: "claude",
+    state: "waiting_approval",
+    confidence: 0.8,
+    source: "pty_output",
+    updatedAt: 1150
+  });
+
+  assert.equal(registry.getPrioritySession().sessionId, "claude");
+  assert.equal(registry.getPrioritySession({ pinnedSessionId: "codex" }).sessionId, "codex");
+});
+
+test("marks stale non-exited sessions after heartbeat timeout", () => {
+  const registry = createSessionRegistry({ staleAfterMs: 100 });
+
+  registry.applyMessage(registerMessage("active", { startedAt: 1000 }));
+  registry.applyMessage(registerMessage("finished", { startedAt: 1000 }));
+  registry.applyMessage({
+    type: "unregister",
+    sessionId: "finished",
+    exitCode: 0,
+    finishedAt: 1050
+  });
+
+  const staleSessions = registry.markStaleSessions(1201);
+
+  assert.deepEqual(staleSessions.map((session) => session.sessionId), ["active"]);
+  assert.equal(registry.getSession("active").state, "stale");
+  assert.equal(registry.getSession("active").source, "wrapper");
+  assert.equal(registry.getSession("finished").state, "exited");
+});
+
+test("drops sessions with no activity past the drop timeout", () => {
+  const registry = createSessionRegistry({ staleAfterMs: 100, dropAfterMs: 500 });
+  registry.applyMessage(registerMessage("dead", { startedAt: 1000 }));
+
+  // Past staleAfterMs but within dropAfterMs -> marked stale, still present.
+  registry.markStaleSessions(1200);
+  assert.equal(registry.getSession("dead").state, "stale");
+
+  // Marking stale must not refresh updatedAt, so the drop clock still elapses.
+  registry.markStaleSessions(1600);
+  assert.equal(registry.getSession("dead"), undefined);
+  assert.deepEqual(registry.listSessions(), []);
+});
+
+test("does not re-mark an already-stale session every sweep", () => {
+  const registry = createSessionRegistry({ staleAfterMs: 100, dropAfterMs: 100000 });
+  registry.applyMessage(registerMessage("idle1", { startedAt: 1000 }));
+
+  assert.deepEqual(registry.markStaleSessions(1200).map((s) => s.sessionId), ["idle1"]);
+  // already stale -> not reported again
+  assert.deepEqual(registry.markStaleSessions(1300), []);
+});
+
+test("rejects updates for unknown sessions", () => {
+  const registry = createSessionRegistry();
+
+  assert.throws(
+    () => registry.applyMessage({ type: "heartbeat", sessionId: "missing", updatedAt: 1 }),
+    /Unknown session: missing/
+  );
+});

package/packages/session-core/test/summaries.test.mjs

@@ -0,0 +1,38 @@
+import assert from "node:assert/strict";
+import { test } from "../../../test/harness.mjs";
+import {
+  buildStatusLabel,
+  buildSessionSummary,
+  formatElapsed
+} from "../src/summaries.js";
+
+test("maps every normalized state to a human status label", () => {
+  assert.equal(buildStatusLabel("waiting_approval"), "Waiting for approval");
+  assert.equal(buildStatusLabel("waiting_user"), "Waiting for you");
+  assert.equal(buildStatusLabel("running_tool"), "Running tools");
+  assert.equal(buildStatusLabel("editing_files"), "Editing files");
+  assert.equal(buildStatusLabel("success"), "Done");
+  assert.equal(buildStatusLabel("idle"), "Idle");
+});
+
+test("falls back to a readable label for unknown states", () => {
+  assert.equal(buildStatusLabel("totally_unknown"), "Totally unknown");
+});
+
+test("prefers an explicit summary but falls back to the status label", () => {
+  assert.equal(
+    buildSessionSummary({ state: "running_tool", summary: "npm test" }),
+    "npm test"
+  );
+  assert.equal(
+    buildSessionSummary({ state: "waiting_approval" }),
+    "Waiting for approval"
+  );
+});
+
+test("formats elapsed durations compactly", () => {
+  assert.equal(formatElapsed(0), "0s");
+  assert.equal(formatElapsed(5_000), "5s");
+  assert.equal(formatElapsed(65_000), "1m 5s");
+  assert.equal(formatElapsed(3_725_000), "1h 2m");
+});

package/packages/task-core/src/approvals.js

@@ -0,0 +1,91 @@
+export const APPROVAL_KINDS = Object.freeze([
+  "command",
+  "file_write",
+  "network",
+  "sandbox",
+  "plugin",
+  "permission",
+  "other"
+]);
+
+export const APPROVAL_RISKS = Object.freeze(["low", "medium", "high"]);
+
+const APPROVAL_KIND_SET = new Set(APPROVAL_KINDS);
+const APPROVAL_RISK_SET = new Set(APPROVAL_RISKS);
+
+export function validateApprovalRequest(input) {
+  if (!isPlainObject(input)) {
+    return { ok: false, errors: ["approval request must be an object"] };
+  }
+
+  const errors = [];
+
+  requireNonEmptyString(errors, input.approvalId, "approvalId");
+  requireNonEmptyString(errors, input.sessionId, "sessionId");
+  requireNonEmptyString(errors, input.title, "title");
+
+  if (!APPROVAL_KIND_SET.has(input.kind)) {
+    errors.push(`kind must be one of: ${APPROVAL_KINDS.join(", ")}`);
+  }
+
+  if (input.risk !== undefined && !APPROVAL_RISK_SET.has(input.risk)) {
+    errors.push(`risk must be one of: ${APPROVAL_RISKS.join(", ")}`);
+  }
+
+  if (!Number.isFinite(input.requestedAt)) {
+    errors.push("requestedAt must be a finite number");
+  }
+
+  return { ok: errors.length === 0, errors };
+}
+
+export function buildApprovalDecision({ sessionId, approvalId, decision, note, decidedAt }) {
+  const result = {
+    type: "approval_decision",
+    sessionId,
+    approvalId,
+    decision,
+    decidedAt
+  };
+
+  if (note !== undefined) {
+    result.note = note;
+  }
+
+  return result;
+}
+
+export function validateApprovalDecision(input) {
+  if (!isPlainObject(input)) {
+    return { ok: false, errors: ["approval decision must be an object"] };
+  }
+
+  const errors = [];
+
+  if (input.type !== "approval_decision") {
+    errors.push('type must be "approval_decision"');
+  }
+
+  requireNonEmptyString(errors, input.sessionId, "sessionId");
+  requireNonEmptyString(errors, input.approvalId, "approvalId");
+
+  if (input.decision !== "approve" && input.decision !== "deny") {
+    errors.push('decision must be "approve" or "deny"');
+  }
+
+  if (!Number.isFinite(input.decidedAt)) {
+    errors.push("decidedAt must be a finite number");
+  }
+
+  return { ok: errors.length === 0, errors };
+}
+
+function requireNonEmptyString(errors, value, fieldName) {
+  if (typeof value !== "string" || value.trim() === "") {
+    errors.push(`${fieldName} must be a non-empty string`);
+  }
+}
+
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}