portable-agent-layer 0.113.0 → 0.114.0-canary.2

package/assets/schema/pal-settings.schema.json

@@ -82,6 +82,10 @@
           "type": "boolean",
           "description": "Opt-in, off by default until 1.0. Send a turn back when it committed, made a branch, opened a PR or published an artifact without recording it in the work tree (pal cli work). Needs workTree."
         },
+        "workTreeDecisionGate": {
+          "type": "boolean",
+          "description": "Opt-in, off by default until 1.0. Send a turn back when a small-model check finds it settled a decision that no pal cli work decide recorded. One small-model call at the end of every turn. Needs workTree."
+        },
         "dueReminders": {
           "type": "boolean",
           "description": "Opt-in, off by default until 1.0. Due maintenance reminders (learning analysis, relationship reflect) with every prompt until a reply names their command; then quiet until the next day."

package/assets/templates/pal-settings.json

@@ -29,6 +29,7 @@
     "repoState": true,
     "workTree": false,
     "workTreeGate": false,
+    "workTreeDecisionGate": false,
     "dueReminders": false,
     "interactionAwareness": true,
     "reactionSampling": true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "portable-agent-layer",
-  "version": "0.113.0",
+  "version": "0.114.0-canary.2",
   "description": "PAL — Portable Agent Layer: persistent personal context for AI coding assistants",
   "type": "module",
   "bin": {
@@ -74,7 +74,9 @@
     "eval:correction-kind": "bun eval/correction-kind/build-prompt.ts && bun eval/run.ts correction-kind",
     "eval:correction-kind:test": "bun eval/correction-kind/test-set.ts",
     "eval:rule-drafter": "bun eval/rule-drafter/build-prompt.ts && bun eval/run.ts rule-drafter",
-    "eval:rule-drafter:test": "bun eval/rule-drafter/test-set.ts"
+    "eval:rule-drafter:test": "bun eval/rule-drafter/test-set.ts",
+    "eval:decision": "bun eval/decision/score.ts validation",
+    "eval:decision:test": "bun eval/decision/score.ts test"
   },
   "lint-staged": {
     "*.ts": [

package/src/hooks/LoadContext.ts

@@ -14,6 +14,7 @@ import { buildClaudeMd, regenerateIfNeeded } from "./lib/claude-md";
 import { type AgentTarget, buildSystemReminder } from "./lib/context";
 import { logContextInjected } from "./lib/context-overhead";
 import { duplicatesCursorHooks } from "./lib/cursor-shadow";
+import { hookSessionId } from "./lib/hook-turn";
 import { logContextSnapshot, logDebug, logError } from "./lib/log";
 import {
   contextEnvelope,
@@ -62,6 +63,7 @@ try {
   const reminder = buildSystemReminder({
     agent: target,
     withoutHandoff: wanted === "without-handoff",
+    sessionId: hookSessionId(input),
   });
   if (!reminder) process.exit(0);
   logContextSnapshot(reminder);

package/src/hooks/StopOrchestrator.ts

@@ -64,7 +64,7 @@ try {
   logError("StopOrchestrator:adaptation-rules", err);
 }
 try {
-  const sendBack = stopWorkTree(payload);
+  const sendBack = await stopWorkTree(payload);
   if (sendBack) {
     process.stdout.write(stopBlockResponse(sendBack));
     process.exit(0);

package/src/hooks/handlers/inject-retrieval.ts

@@ -89,7 +89,7 @@ export async function getPromptContext(
     getWallClockReminder(),
     userText && withinBudget(() => promptRulesReminder(userText, sessionId), BUDGET_MS),
     withinBudget(() => getRepoStateReminder(), BUDGET_MS),
-    withinBudget(() => workTreePromptLine(userText), BUDGET_MS),
+    withinBudget(() => workTreePromptLine(userText, undefined, sessionId), BUDGET_MS),
     userText && withinBudget(() => observeTurn(userText, sessionId), BUDGET_MS),
     withinBudget(() => dueNudgeReminder(), BUDGET_MS),
     userText && getSteeringReminder(userText),

package/src/hooks/lib/claim-check.ts

@@ -137,6 +137,14 @@ function isUserPrompt(entry: TranscriptLine): boolean {
   return text !== null && !isSystemText(text) && !isCodexInjectedContext(text);
 }
 
+export function promptThisTurn(lines: string[]): string | null {
+  const prompts = lines
+    .map(parsed)
+    .filter((e): e is TranscriptLine => e !== null && isUserPrompt(e));
+  const last = prompts.at(-1);
+  return last ? promptText(last) : null;
+}
+
 const ran = (input: unknown) => JSON.stringify(input ?? {});
 
 function callsIn(entry: TranscriptLine, tools: ReadonlySet<string>): string[] {

package/src/hooks/lib/context.ts

@@ -194,7 +194,7 @@ export type AgentTarget = Extract<
  * wisdom, opinions) that load natively via @imports in CLAUDE.md.
  */
 export function buildSystemReminder(
-  opts: { agent?: AgentTarget; withoutHandoff?: boolean } = {}
+  opts: { agent?: AgentTarget; withoutHandoff?: boolean; sessionId?: string } = {}
 ): string {
   // Semi-static sections loaded natively via @imports (Claude Code) or
   // instructions[] (opencode). Skip them from hook output for those agents.
@@ -224,7 +224,7 @@ export function buildSystemReminder(
     !opts.withoutHandoff && settings.isEnabled("handoff")
       ? loadHandoffContext(sessionDir())
       : "";
-  const workTree = loadWorkTreeContext(sessionDir());
+  const workTree = loadWorkTreeContext(sessionDir(), opts.sessionId);
   const dueNudges = opts.agent === "cursor" ? dueNudgeSections() : [];
   const parts: string[] = [];
   if (startup) parts.push(startup);

package/src/hooks/lib/decision-label.ts

@@ -0,0 +1,70 @@
+/**
+ * Whether a turn settled a decision. Code can see that a turn committed or
+ * opened a PR, but a decision is only words, so the work-tree gate asks the
+ * small model and sends the turn back when nothing was recorded.
+ */
+
+export interface DecisionLabel {
+  decision: boolean;
+  what: string;
+}
+
+const DECISION_SYSTEM = `You read one turn of a working session between a user and an AI assistant: the user's message and the end of the assistant's reply. Say whether the turn settled a decision.
+
+A decision is a choice between alternatives about the work that holds beyond this turn: a policy, a design, a direction, a scope (what is in, out, parked or dropped), or a standing way of working. Examples: "make them opt in for now", "we only track new posts, not past ones", "we don't need the predictor", "PRs go to canary from now on".
+
+A decision is often a few words that answer something open earlier: picking one of the options the assistant offered, keeping something where it is, saying something is not needed or should wait, changing how a thing behaves. Read the reply to see what the user's words settled; a short message can still be a decision.
+
+These are not decisions:
+- a go-ahead or approval of a plan or of the assistant's proposals as they stand ("go", "yes pls", "build all of them", "ok to both, build it"), unless it also picks between alternatives or changes the plan;
+- where the work goes (which branch or PR) and other bookkeeping the assistant handles;
+- a plain request for work ("fix CI", "push and open a PR", "plan it", "list our tasks"), including which step comes first;
+- a question, even one about what to decide or what was decided before;
+- a fact, a status report, or an idea floated for discussion;
+- a recommendation or proposal from the assistant that the user has not accepted;
+- small implementation choices the assistant makes while working.
+
+Most turns settle no decision. When unsure, answer false.
+
+Set what to the decision in under fifteen words, or to an empty string when there is none.`;
+
+const DECISION_SCHEMA = {
+  type: "object",
+  properties: {
+    decision: { type: "boolean" },
+    what: { type: "string" },
+  },
+  required: ["decision", "what"],
+  additionalProperties: false,
+} as const;
+
+const MESSAGE_MAX = 1500;
+const REPLY_END_MAX = 1500;
+
+export function decisionUser(message: string, reply: string) {
+  return `The user's message:\n<message>\n${message.slice(0, MESSAGE_MAX)}\n</message>\n\nThe end of the assistant's reply:\n<reply_end>\n${reply.slice(-REPLY_END_MAX)}\n</reply_end>`;
+}
+
+export function decisionRequest(message: string, reply: string, sessionId?: string) {
+  return {
+    system: DECISION_SYSTEM,
+    user: decisionUser(message, reply),
+    maxTokens: 100,
+    timeout: 60_000,
+    jsonSchema: DECISION_SCHEMA,
+    caller: "decision-label",
+    sessionId,
+  };
+}
+
+export function parseDecision(output: string | null | undefined): DecisionLabel | null {
+  if (!output) return null;
+  try {
+    const parsed = JSON.parse(output) as Record<string, unknown>;
+    if (typeof parsed.decision !== "boolean") return null;
+    const what = typeof parsed.what === "string" ? parsed.what.trim() : "";
+    return { decision: parsed.decision, what: parsed.decision ? what : "" };
+  } catch {
+    return null;
+  }
+}

package/src/hooks/lib/models.ts

@@ -76,7 +76,11 @@ export function isFixedModelRoute(route: string): route is FixedModelRoute {
  * caller, whose eval is iterated on 5.5 until it passes. The rest stay on
  * HAIKU_MODEL until theirs is evaluated.
  */
-const ANTHROPIC_ON_HAIKU_5_5 = new Set(["rule-drafter", "correction-kind"]);
+const ANTHROPIC_ON_HAIKU_5_5 = new Set([
+  "rule-drafter",
+  "correction-kind",
+  "decision-label",
+]);
 
 function evaluatedModel(
   models: RouteModels,

package/src/hooks/lib/work-session.ts

@@ -0,0 +1,28 @@
+/**
+ * Which session a piece of work-tree activity belongs to, so parallel sessions
+ * in one project each keep their own active node. A hook knows its session
+ * from the payload, but `pal cli work` runs in the agent's shell and knows it
+ * only from what the agent exports there, so only agents that export it get
+ * their own lane; the rest share one, as every session did before.
+ */
+
+import { type AgentType, getActiveAgent } from "./agent";
+
+const SHELL_SESSION_ENV: Partial<Record<AgentType, string>> = {
+  claude: "CLAUDE_CODE_SESSION_ID",
+  codex: "CODEX_THREAD_ID",
+  copilot: "COPILOT_AGENT_SESSION_ID",
+  antigravity: "ANTIGRAVITY_CONVERSATION_ID",
+  opencode: "PAL_OPENCODE_SESSION_ID",
+  cursor: "CURSOR_CONVERSATION_ID",
+};
+
+export function workSession(
+  hookSession?: string,
+  env: NodeJS.ProcessEnv = process.env,
+  agent: AgentType = getActiveAgent()
+): string | undefined {
+  const variable = SHELL_SESSION_ENV[agent];
+  if (!variable) return undefined;
+  return hookSession || env[variable] || undefined;
+}

package/src/hooks/lib/work-tree-context.ts

@@ -6,20 +6,29 @@
 import { reactionTo } from "./interaction-reaction";
 import { sessionDir } from "./session-dir";
 import { isOptedIn } from "./settings";
+import { workSession } from "./work-session";
 import { readTree, scopeOf } from "./work-tree";
 import { renderPromptLine, renderSessionContext } from "./work-tree-render";
 
-export function loadWorkTreeContext(cwd: string = sessionDir()): string {
+function sessionTree(cwd: string, hookSession: string | undefined) {
+  return readTree(scopeOf(cwd), undefined, workSession(hookSession));
+}
+
+export function loadWorkTreeContext(
+  cwd: string = sessionDir(),
+  hookSession?: string
+): string {
   if (!isOptedIn("workTree")) return "";
-  return renderSessionContext(readTree(scopeOf(cwd)));
+  return renderSessionContext(sessionTree(cwd, hookSession));
 }
 
 export function workTreePromptLine(
   userText: string,
-  cwd: string = sessionDir()
+  cwd: string = sessionDir(),
+  hookSession?: string
 ): string | null {
   if (!isOptedIn("workTree")) return null;
   const newTopic = userText !== "" && reactionTo(userText, undefined) === "new-topic";
-  const line = renderPromptLine(readTree(scopeOf(cwd)), newTopic);
+  const line = renderPromptLine(sessionTree(cwd, hookSession), newTopic);
   return line ? `<system-reminder>${line}</system-reminder>` : null;
 }

package/src/hooks/lib/work-tree-gate.ts

@@ -4,16 +4,21 @@
  * nothing in the tree is sent back once to record it.
  */
 
-import { callsThisTurn, commandsThisTurn } from "./claim-check";
+import { callsThisTurn, commandsThisTurn, promptThisTurn } from "./claim-check";
 import { alreadySentBack, transcriptLines } from "./claim-log";
+import { type DecisionLabel, decisionRequest, parseDecision } from "./decision-label";
+import { hookFinalReply, hookSessionId } from "./hook-turn";
+import { inference } from "./inference";
 import { sessionDir } from "./session-dir";
 import { isOptedIn } from "./settings";
 import type { StopTurnPayload } from "./stop";
+import { workSession } from "./work-session";
 import { readTree, scopeOf } from "./work-tree";
 import { attachGitProgress } from "./work-tree-git";
 import { renderPromptLine } from "./work-tree-render";
 
 const RECORDS_WORK_RE = /\bpal\s+cli\s+work\b/;
+const RECORDS_DECISION_RE = /\bpal\s+cli\s+work\s+decide\b/;
 
 const PRODUCERS: { what: string; re: RegExp }[] = [
   { what: "committed", re: /\bgit\s+commit\b/ },
@@ -34,8 +39,17 @@ function producedThisTurn(commands: string[], lines: string[]): string[] {
   return produced;
 }
 
-function sendBackReason(produced: string[], scope: string): string {
-  const where = renderPromptLine(readTree(scope), false) ?? "Work: nothing recorded yet";
+function whereWorkStands(scope: string, payload: StopTurnPayload): string {
+  const tree = readTree(scope, undefined, workSession(hookSessionId(payload)));
+  return renderPromptLine(tree, false) ?? "Work: nothing recorded yet";
+}
+
+function sendBackReason(
+  produced: string[],
+  scope: string,
+  payload: StopTurnPayload
+): string {
+  const where = whereWorkStands(scope, payload);
   return [
     `This turn ${produced.join(", ")} but recorded nothing in the work tree (${where}).`,
     'Record where the work stands with `pal cli work stopped "…"`, plus `decide` or `attach` where they fit;',
@@ -53,15 +67,51 @@ export function workTreeSendBack(
   const commands = commandsThisTurn(lines);
   if (commands === null || commands.some((c) => RECORDS_WORK_RE.test(c))) return null;
   const produced = producedThisTurn(commands, lines);
-  return produced.length > 0 ? sendBackReason(produced, scopeOf(cwd)) : null;
+  return produced.length > 0 ? sendBackReason(produced, scopeOf(cwd), payload) : null;
+}
+
+type LabelDecision = (message: string, reply: string) => Promise<DecisionLabel | null>;
+
+async function labelWithInference(message: string, reply: string) {
+  const result = await inference(decisionRequest(message, reply));
+  return result.success ? parseDecision(result.output) : null;
+}
+
+function decisionReason(what: string, scope: string, payload: StopTurnPayload): string {
+  return [
+    `This turn settled a decision (${what}) but recorded none in the work tree (${whereWorkStands(scope, payload)}).`,
+    'Record it with `pal cli work decide "…"`; if no node fits, open one first with `pal cli work open "…"`.',
+  ].join(" ");
+}
+
+export async function decisionSendBack(
+  payload: StopTurnPayload,
+  lines: string[],
+  cwd: string,
+  label: LabelDecision = labelWithInference
+): Promise<string | null> {
+  if (!isOptedIn("workTree") || !isOptedIn("workTreeDecisionGate")) return null;
+  if (alreadySentBack(payload)) return null;
+  const commands = commandsThisTurn(lines);
+  if (commands === null || commands.some((c) => RECORDS_DECISION_RE.test(c))) return null;
+  const message = promptThisTurn(lines);
+  const reply = hookFinalReply(payload);
+  if (!message || !reply) return null;
+  const decided = await label(message, reply);
+  return decided?.decision ? decisionReason(decided.what, scopeOf(cwd), payload) : null;
 }
 
 /** The reason to send the turn back with, or null after attaching what git moved. */
-export function stopWorkTree(payload: StopTurnPayload | null): string | null {
+export async function stopWorkTree(
+  payload: StopTurnPayload | null
+): Promise<string | null> {
   if (!payload || !isOptedIn("workTree")) return null;
   const cwd = sessionDir();
-  const sendBack = workTreeSendBack(payload, transcriptLines(payload), cwd);
+  const lines = transcriptLines(payload);
+  const sendBack =
+    workTreeSendBack(payload, lines, cwd) ??
+    (await decisionSendBack(payload, lines, cwd));
   if (sendBack) return sendBack;
-  attachGitProgress(cwd);
+  attachGitProgress(cwd, undefined, undefined, workSession(hookSessionId(payload)));
   return null;
 }

package/src/hooks/lib/work-tree-git.ts

@@ -4,6 +4,7 @@
  */
 
 import { spawnSync } from "node:child_process";
+import { workSession } from "./work-session";
 import { appendEvent, readTree, scopeOf } from "./work-tree";
 
 const GIT_TIMEOUT_MS = 1000;
@@ -57,10 +58,11 @@ function ownCommitsSince(cwd: string, from: string, to: string, email: string):
 export function attachGitProgress(
   cwd: string,
   file?: string,
-  now: Date = new Date()
+  now: Date = new Date(),
+  session: string | undefined = workSession()
 ): void {
   const scope = scopeOf(cwd);
-  const tree = readTree(scope, file);
+  const tree = readTree(scope, file, session);
   if (tree.nodes.size === 0) return;
   const current = snapshot(cwd);
   if (!current) return;

package/src/hooks/lib/work-tree-render.ts

@@ -3,7 +3,13 @@
  * compacted session starts with, and the one line every prompt carries.
  */
 
-import { activePath, nodesWithStatus, type ScopeTree, type WorkNode } from "./work-tree";
+import {
+  activeElsewhere,
+  activePath,
+  nodesWithStatus,
+  type ScopeTree,
+  type WorkNode,
+} from "./work-tree";
 
 const SESSION_BUDGET = 2_000;
 const RECENT_DECISIONS = 3;
@@ -102,7 +108,7 @@ export function renderTreeList(tree: ScopeTree, includeDone: boolean): string {
 function activeSection(tree: ScopeTree): string[] {
   const path = activePath(tree);
   const active = path.at(-1);
-  if (!active) return ["Active: none — enter a parked node or open one."];
+  if (!active) return ["Active: none in this session — enter a node below or open one."];
   const lines = [`Active: ${label(active)}${stoppedClause(active)}`];
   if (path.length > 1) lines.push(`  Inside: ${path.map((n) => n.title).join(" › ")}`);
   for (const d of active.decisions.slice(-RECENT_DECISIONS))
@@ -122,6 +128,10 @@ export function renderSessionContext(tree: ScopeTree): string {
   const lines = [
     `## Work tree — ${tree.scope}`,
     ...activeSection(tree),
+    ...listSection(
+      "Active in other sessions:",
+      activeElsewhere(tree).map((n) => `${label(n)}${stoppedClause(n)}`)
+    ),
     ...listSection(
       "Waiting on the user:",
       nodesWithStatus(tree, "waiting").map((n) => `${label(n)}: ${n.waitingOn}`)
@@ -149,9 +159,11 @@ export function renderPromptLine(tree: ScopeTree, newTopic: boolean): string | n
   if (tree.nodes.size === 0) return null;
   const active = tree.active ? tree.nodes.get(tree.active) : undefined;
   const parked = nodesWithStatus(tree, "parked").length;
+  const elsewhere = activeElsewhere(tree).length;
   const head = active
     ? `Work: ${label(active)}${stoppedClause(active)}`
-    : "Work: no active node";
-  const line = clip(`${head} · ${parked} parked`, PROMPT_LINE_MAX);
+    : "Work: no active node in this session";
+  const tail = elsewhere ? ` · ${elsewhere} active in other sessions` : "";
+  const line = clip(`${head} · ${parked} parked${tail}`, PROMPT_LINE_MAX);
   return newTopic ? `${line}\n${NEW_TOPIC_HINT}` : line;
 }

package/src/hooks/lib/work-tree.ts

@@ -9,6 +9,7 @@ import { appendFileSync, existsSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { ensureDir, paths } from "./paths";
 import { readAllProjects, resolveProjectFromCwd } from "./projects";
+import { workSession } from "./work-session";
 
 export type NodeStatus = "active" | "parked" | "waiting" | "done";
 
@@ -41,6 +42,7 @@ interface EventBase {
   ts: string;
   scope: string;
   node: string;
+  session?: string;
 }
 
 export type WorkEvent = EventBase &
@@ -102,9 +104,11 @@ interface GitCursor {
   head: string;
 }
 
+/** `active` is the viewing session's node; `lanes` holds every session's, keyed by session ("" for none). */
 export interface ScopeTree {
   scope: string;
   active: string | null;
+  lanes: Map<string, string>;
   nodes: Map<string, WorkNode>;
   gitCursor: GitCursor | null;
 }
@@ -149,13 +153,15 @@ export function appendEvent<T extends WorkEvent["type"]>(
   type: T,
   payload: Payload<T>,
   file: string = workTreeFile(),
-  now: Date = new Date()
+  now: Date = new Date(),
+  session: string | undefined = workSession()
 ): WorkEvent {
   const event = {
     id: newNodeId(now.getTime()),
     ts: now.toISOString(),
     scope,
     node,
+    ...(session && { session }),
     type,
     ...payload,
   } as WorkEvent;
@@ -186,50 +192,64 @@ function emptyNode(
   };
 }
 
-function parkActive(tree: ScopeTree): void {
-  const current = tree.active ? tree.nodes.get(tree.active) : undefined;
+function laneOf(event: WorkEvent): string {
+  return event.session ?? "";
+}
+
+function parkLane(tree: ScopeTree, lane: string): void {
+  const current = tree.nodes.get(tree.lanes.get(lane) ?? "");
   if (current?.status === "active") current.status = "parked";
-  tree.active = null;
+  tree.lanes.delete(lane);
+}
+
+/** The lane that held the node, if one did. */
+function release(tree: ScopeTree, node: WorkNode): string | undefined {
+  const held = [...tree.lanes].find(([, id]) => id === node.id)?.[0];
+  if (held !== undefined) tree.lanes.delete(held);
+  return held;
 }
 
-function activate(tree: ScopeTree, node: WorkNode): void {
-  if (tree.active !== node.id) parkActive(tree);
+/** A node is active in one session at a time, so entering it takes it over. */
+function activate(tree: ScopeTree, node: WorkNode, lane: string): void {
+  if (tree.lanes.get(lane) !== node.id) parkLane(tree, lane);
+  release(tree, node);
   node.status = "active";
   node.waitingOn = null;
-  tree.active = node.id;
+  tree.lanes.set(lane, node.id);
 }
 
-/** Finishing a detour hands the work back to the nearest unfinished ancestor. */
-function returnToParent(tree: ScopeTree, node: WorkNode): void {
+function heldElsewhere(tree: ScopeTree, node: WorkNode): boolean {
+  return [...tree.lanes.values()].includes(node.id);
+}
+
+/** Finishing a detour hands the work back to the nearest unfinished ancestor no other session holds. */
+function returnToParent(tree: ScopeTree, node: WorkNode, lane: string): void {
   let parent = node.parent ? tree.nodes.get(node.parent) : undefined;
   while (parent && parent.status === "done")
     parent = parent.parent ? tree.nodes.get(parent.parent) : undefined;
-  if (parent) activate(tree, parent);
+  if (parent && !heldElsewhere(tree, parent)) activate(tree, parent, lane);
 }
 
 function applyToNode(tree: ScopeTree, node: WorkNode, event: WorkEvent): void {
   switch (event.type) {
     case "enter":
-      activate(tree, node);
+      activate(tree, node, laneOf(event));
       break;
     case "park":
       if (event.stoppedAt) node.stoppedAt = event.stoppedAt;
       node.status = "parked";
-      if (tree.active === node.id) tree.active = null;
+      release(tree, node);
       break;
     case "wait":
       node.status = "waiting";
       node.waitingOn = event.on;
-      if (tree.active === node.id) tree.active = null;
+      release(tree, node);
       break;
     case "done": {
-      const wasActive = tree.active === node.id;
       node.status = "done";
       node.summary = event.summary ?? node.summary;
-      if (wasActive) {
-        tree.active = null;
-        returnToParent(tree, node);
-      }
+      const lane = release(tree, node);
+      if (lane !== undefined) returnToParent(tree, node, lane);
       break;
     }
     case "stopped":
@@ -262,21 +282,41 @@ function apply(tree: ScopeTree, event: WorkEvent): void {
     const node = emptyNode(event.node, event.title, event.parent, event.ts);
     node.links = event.links ?? {};
     tree.nodes.set(node.id, node);
-    activate(tree, node);
+    activate(tree, node, laneOf(event));
     return;
   }
   const node = tree.nodes.get(event.node);
   if (node) applyToNode(tree, node, event);
 }
 
-export function buildTree(scope: string, events: WorkEvent[]): ScopeTree {
-  const tree: ScopeTree = { scope, active: null, nodes: new Map(), gitCursor: null };
+export function buildTree(
+  scope: string,
+  events: WorkEvent[],
+  session?: string
+): ScopeTree {
+  const tree: ScopeTree = {
+    scope,
+    active: null,
+    lanes: new Map(),
+    nodes: new Map(),
+    gitCursor: null,
+  };
   for (const event of events) if (event.scope === scope) apply(tree, event);
+  tree.active = tree.lanes.get(session ?? "") ?? null;
   return tree;
 }
 
-export function readTree(scope: string, file: string = workTreeFile()): ScopeTree {
-  return buildTree(scope, readEvents(file));
+export function readTree(
+  scope: string,
+  file: string = workTreeFile(),
+  session: string | undefined = workSession()
+): ScopeTree {
+  return buildTree(scope, readEvents(file), session);
+}
+
+/** Nodes another session is working on right now. */
+export function activeElsewhere(tree: ScopeTree): WorkNode[] {
+  return nodesWithStatus(tree, "active").filter((n) => n.id !== tree.active);
 }
 
 /** From the root down to the active node: the detours the user is inside of. */

package/src/targets/opencode/plugin.ts

@@ -131,9 +131,12 @@ const PALPlugin: Plugin = async ({ directory, client }: PluginInput) => {
 
   return {
     // --- Per-message: Inject dynamic system reminder ---
-    "experimental.chat.system.transform": async (_input, output) => {
+    "experimental.chat.system.transform": async (input, output) => {
       if (isPalSpawnedInference()) return;
-      const reminder = buildSystemReminder({ agent: "opencode" });
+      const reminder = buildSystemReminder({
+        agent: "opencode",
+        sessionId: input.sessionID,
+      });
       if (reminder) output.system.push(reminder);
     },
 
@@ -285,10 +288,11 @@ const PALPlugin: Plugin = async ({ directory, client }: PluginInput) => {
 
     // --- Inject PAL_DIR into shell environment ---
     "shell.env": async (
-      _input: { cwd: string; sessionID?: string; callID?: string },
+      input: { cwd: string; sessionID?: string; callID?: string },
       output: { env: Record<string, string> }
     ) => {
       output.env.PAL_DIR = PAL_DIR;
+      if (input.sessionID) output.env.PAL_OPENCODE_SESSION_ID = input.sessionID;
     },
   };
 };