@brainervirus/workit-core 8.9.0 → 8.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brainervirus/workit-core",
-  "version": "8.9.0",
+  "version": "8.10.0",
   "private": false,
   "description": "Workit shared core — task, policy, evidence, review, decision, worker, and writer state for agentic coding workflows",
   "keywords": [

package/skills/workit-fanout/references/brief.md

@@ -25,7 +25,7 @@ REPORT: branch, head SHA, files changed, each VERIFY command with its exit code,
   each ACCEPTANCE line met / not met, rulings you made (`workit ledger ruling`),
   anything out of scope as a follow-up, not a diff.
 STANDING: <the standing orders, verbatim: `workit ledger standing add` records each one>
-  export WORKIT_SESSION_ID=<lead>-w<n>   (set by the lead; a verifier brief gets <lead>-v<n>)
+  export WORKIT_SESSION_ID=<lead>-w<n>   (set by the lead for a worker's commits; a verifier brief sets none: the host derives it)
 ```
 
 ## Worked example

package/skills/workit-fanout/references/orchestration.md

@@ -72,12 +72,22 @@ Which session id a verdict carries, per host:
 
 - Claude Code: subagents inherit your `WORKIT_SESSION_ID`, so the
   SubagentStart hook names each `verifier` and `reviewer` its own session
-  (`<lead>:<agent id>`), passed as `--session`; that one wins over any
-  `<lead>-v<n>` in a brief. An `implementer` uses the session its brief
-  exports for its workit commands.
-- Other hosts: the session the brief sets wins: `export
-  WORKIT_SESSION_ID=<lead>-w-<slice>` from `workit fanout brief` for a
-  worker, `<lead>-v<n>` (or `--as verifier`) for a verifier you start.
+  (`<lead>:<agent id>`), passed exactly as `--session`: the hook records the
+  ids it issues, and only those are accepted. An `implementer` uses the
+  session its brief exports for its workit commands.
+- Codex: the `workit-verifier` and `workit-reviewer` agents get the same
+  issued `--session` from SubagentStart; any other verifier passes
+  `--as verifier`.
+- OpenCode: a child session's shell already has
+  `WORKIT_SESSION_ID=<lead>:<child>`; Pi: a supervised worker's shell has
+  `<lead>:<worker session>`. Set nothing for a verifier there.
+- Cursor (no session id in the shell): the brief sets the verifier's
+  `WORKIT_SESSION_ID=<lead>:verifier-<random hex>`, a fresh suffix per
+  verifier. Cursor cannot check it: it is declared, not derived.
+- A worker's commits use `export WORKIT_SESSION_ID=<lead>-w-<slice>` from
+  `workit fanout brief`. A verdict under an id you made up (`<lead>-v1`,
+  `<lead>:v1`) is refused as `forged_session` on Claude Code, Codex,
+  OpenCode and Pi.
 
 A batch verifier takes several slices on one surface in one session: for
 each branch it checks out the head, runs that slice's VERIFY, and records its

package/skills/workit-implement/SKILL.md

@@ -33,8 +33,9 @@ description: Build a requested change in small verified steps - follow local pat
    `workit ledger verdict tests-verified --self --how "<what you ran>"`; it
    reads self-reviewed, never verified. High risk, a workspace with
    `verification: independent` (`workit grant show`) or a verified merge needs
-   a fresh verifier with its own session (`WORKIT_SESSION_ID=<yours>-v1`;
-   Claude Code: the `verifier` agent). Before saying done, reconcile
+   a fresh verifier with its own host-derived session (Claude Code and Codex:
+   the `verifier` agent; OpenCode: a child session; Pi: a supervised worker),
+   never a hand-minted id. Before saying done, reconcile
    every named deliverable against the target checkout and observe it (for a push:
    `workit verify-delivery push`).
 

package/skills/workit-review/SKILL.md

@@ -7,8 +7,10 @@ description: Independent review of a diff, branch or PR - intent fidelity and st
 
 Review the candidate, never the author's summary of it. A session that wrote a
 commit on the branch cannot record a passing verdict: if that is you, hand the
-review to a fresh agent with its own session (`WORKIT_SESSION_ID=<lead>-v<n>`;
-Claude Code: the `reviewer` or `verifier` agent).
+review to a fresh agent with its own host-derived session: Claude Code and
+Codex, the `reviewer` or `verifier` agent (`--session` from SubagentStart);
+OpenCode, a child session; Pi, a supervised worker. Never hand-mint one such
+as `<lead>-v1`: it is refused as `forged_session`.
 An author's `--self` verdict reads self-reviewed and never counts as
 independent; `type-check-only` never proves a behavior change.
 

package/src/core/methods.ts

@@ -115,7 +115,8 @@ Autonomy contract:
   satisfies a gate; an ad-hoc \`workit check -- <cmd>\` never does.
 - Author is not verifier: your own verdict is \`--self\`, shown as
   self-reviewed, never verified. High risk, \`verification: independent\` and
-  merge need a verifier with its own session (\`WORKIT_SESSION_ID=<lead>-v<n>\`).
+  merge need a verifier with its own host-derived session (a subagent's
+  \`<lead>:<child>\`, set by the host); never hand-mint one such as \`<lead>-v1\`.
 - A local-commit endpoint does not imply PR readiness, and a local commit alone
   is not evidence of a requested remote push. Before reporting delivery,
   reconcile every requested item and observe it (\`workit verify-delivery\`).

package/src/core/task-context.ts

@@ -73,11 +73,20 @@ type CompactDecision = {
   digest: string;
   choice: string;
   references: CompactReference[];
+  /** Where an inherited decision was recorded ("branch develop"); absent for the task's own. */
+  origin?: string;
 };
 type CompactMethod = Pick<SelectedMethod, "id" | "assurance"> & { reason: string };
+/** Decisions of a task the current one inherits from (its base branch's task). */
+export type InheritedDecisions = {
+  origin: string;
+  taskId: string;
+  decisions: TaskView["task"]["decisions"];
+};
 export type CompactTaskContext = {
   objective: string;
-  status: TaskView["task"]["status"];
+  /** Null when the checkout has no task yet and only inherited decisions apply. */
+  status: TaskView["task"]["status"] | null;
   decisions: CompactDecision[];
   methods: CompactMethod[];
   gaps: string[];
@@ -128,54 +137,83 @@ const compactReference = (ref: Ref): CompactReference => {
   return { kind: ref.kind };
 };
 
-export function compactTaskContext(view: TaskView): string {
-  const decisions: CompactDecision[] = view.task.decisions
-    .slice()
-    .toSorted((left, right) => {
-      const leftAt = compactTimestamp(left.recordedAt);
-      const rightAt = compactTimestamp(right.recordedAt);
-      if (leftAt !== rightAt) return leftAt > rightAt ? -1 : 1;
-      return left.id < right.id ? -1 : left.id > right.id ? 1 : 0;
-    })
-    .slice(0, COMPACT_MAX_ITEMS)
-    .map((entry) => ({
-      id: entry.id,
-      purpose: entry.data.purpose,
-      status: entry.data.response,
-      digest: entry.data.digest,
-      choice:
-        compactDecisionChoice(entry) ||
-        `task.inspect taskId=${view.task.id} view=full; decision=${entry.id}`,
-      references: entry.data.binding.contentRefs.slice(0, 1).map(compactReference),
-    }));
-  const methods: CompactMethod[] = view.task.policy
+type TaskDecision = TaskView["task"]["decisions"][number];
+const newestDecisionFirst = (left: TaskDecision, right: TaskDecision): number => {
+  const leftAt = compactTimestamp(left.recordedAt);
+  const rightAt = compactTimestamp(right.recordedAt);
+  if (leftAt !== rightAt) return leftAt > rightAt ? -1 : 1;
+  return left.id < right.id ? -1 : left.id > right.id ? 1 : 0;
+};
+/**
+ * The task's own decisions (newest first), then the ones it inherits (origin
+ * set; the engine passes only unrevoked ones), at most COMPACT_MAX_ITEMS.
+ */
+const compactDecisions = (
+  sources: Array<{ origin: string | null; taskId: string; decisions: TaskDecision[] } | null>,
+): CompactDecision[] =>
+  sources
+    .flatMap((source) =>
+      source
+        ? source.decisions.toSorted(newestDecisionFirst).map((entry) => ({
+            id: entry.id,
+            purpose: entry.data.purpose,
+            status: entry.data.response,
+            digest: entry.data.digest,
+            choice:
+              compactDecisionChoice(entry) ||
+              `task.inspect taskId=${source.taskId} view=full; decision=${entry.id}`,
+            references: entry.data.binding.contentRefs.slice(0, 1).map(compactReference),
+            // Undefined (dropped from the JSON) for the task's own decisions.
+            origin: source.origin ?? undefined,
+          }))
+        : [],
+    )
+    .slice(0, COMPACT_MAX_ITEMS);
+
+/**
+ * The compact context of `view`'s task plus the decisions it inherits; with
+ * a null `view` (the branch has no task of its own yet) only the inherited
+ * decisions. Stale evidence is one counted gap with the command that lists it.
+ */
+export function compactTaskContext(
+  view: TaskView | null,
+  inherited: InheritedDecisions | null = null,
+): string {
+  const decisions = compactDecisions([
+    view && { origin: null, taskId: view.task.id, decisions: view.task.decisions },
+    inherited,
+  ]);
+  const methods: CompactMethod[] = view?.task.policy
     ? selectMethods(view.task.policy, view.capabilities).map((method) => ({
         id: method.id,
         assurance: method.assurance,
         reason: compactText(method.reason, COMPACT_TEXT_BYTES) ?? "",
       }))
     : [];
+  const stale = view?.evidence.filter((entry) => entry.status === "stale").length;
   const gaps = Array.from(
     new Set([
-      ...view.evidence
-        .filter((entry) => entry.status === "stale")
-        .map((entry) => `stale evidence: ${entry.evidenceId}`),
-      ...view.requirements
+      ...(stale
+        ? [`stale evidence: ${stale}; workit task inspect --task ${view.task.id} --view full`]
+        : []),
+      ...(view?.requirements ?? [])
         .filter((entry) => entry.status !== "satisfied")
         .map((entry) => entry.reason),
-      ...view.task.progress.blockers.map((entry) => entry.reason),
+      ...(view?.task.progress.blockers ?? []).map((entry) => entry.reason),
     ]),
   )
     .toSorted()
     .slice(0, COMPACT_MAX_ITEMS)
     .map((gap) => compactText(gap, COMPACT_TEXT_BYTES)!);
   const context: CompactTaskContext = {
-    objective: compactText(view.task.intent.data.objective, COMPACT_TEXT_BYTES) ?? "",
-    status: view.task.status,
+    objective: view
+      ? (compactText(view.task.intent.data.objective, COMPACT_TEXT_BYTES) ?? "")
+      : "no task on this branch yet",
+    status: view?.task.status ?? null,
     decisions,
     methods,
     gaps,
-    nextAction: compactText(view.task.progress.nextAction, COMPACT_TEXT_BYTES),
+    nextAction: compactText(view?.task.progress.nextAction ?? null, COMPACT_TEXT_BYTES),
   };
   let encoded = JSON.stringify(context);
   while (

package/src/core/task-engine.ts

@@ -68,6 +68,7 @@ import { defaultLockTimeout } from "./store-lock";
 import {
   compactTaskContext,
   exportDigest,
+  type InheritedDecisions,
   reconcileResume as reconcileResumeContext,
   type ResumeReconciliation,
 } from "./task-context";
@@ -389,6 +390,18 @@ const TASK_SCOPED_ACTIONS: ReadonlySet<string> = new Set([
   "worker.cancel",
   "state.export",
 ]);
+/** Worker actions that name their worker: they resolve to that worker's task. */
+const WORKER_ADDRESSED_ACTIONS: ReadonlySet<string> = new Set(["worker.cancel", "worker.report"]);
+/**
+ * The exact CLI command that runs worker `request` (cancel or report, with a
+ * valid workerId) on `taskId`, so a retry never depends on the branch.
+ */
+const workerCommand = (taskId: string, request: unknown): string => {
+  const { action, workerId, reason, report } = request as Record<string, unknown>;
+  const rest = JSON.stringify({ reason, report });
+  const payload = rest === "{}" ? "" : ` --payload '${rest.replace(/'/gu, "'\\''")}'`;
+  return `workit worker ${String(action)} ${String(workerId)} --task ${taskId}${payload}`;
+};
 /** Recording actions that create the implicit task on first use. */
 const CREATING_ACTIONS: ReadonlySet<string> = new Set([
   "task.revise",
@@ -711,6 +724,24 @@ export class WorkitCore {
     if (!TASK_SCOPED_ACTIONS.has(action)) return success(null, null, request);
     const root = this.contextRootError();
     if (!root.ok) return root;
+    // A worker belongs to the task it was assigned on, whatever branch is
+    // checked out now (#264): worker.cancel/report follow the named worker,
+    // a helper's own calls follow its worker id.
+    const addressed = WORKER_ADDRESSED_ACTIONS.has(action);
+    // A missing or malformed id is invalid_input (from taskForWorker).
+    const workerId: unknown = addressed
+      ? (value as { workerId?: unknown }).workerId
+      : (this.context.workerId ?? null);
+    if (workerId !== null) {
+      const owner = this.store.taskForWorker(workerId);
+      if (!owner.ok) return owner;
+      if (owner.data) return success(null, null, { ...request, taskId: owner.data });
+      if (addressed)
+        return failure(
+          "not_found",
+          `worker ${workerId as string} is on no open task; find its task with \`workit task status --all\`, then run \`${workerCommand("<task-id>", request)}\``,
+        );
+    }
     const create = CREATING_ACTIONS.has(action) && (this.context.workerId ?? null) === null;
     const found = this.store.implicitTask({
       provenance: provenance(this.context),
@@ -1605,7 +1636,16 @@ export class WorkitCore {
     const resolved = this.implicitTask("worker", request);
     if (!resolved.ok) return resolved;
     const value = resolved.data;
-    return this.retryOmittedRevisions(value, () => this.workerOnce(value));
+    const result = this.retryOmittedRevisions(value, () => this.workerOnce(value));
+    // A cancel/report whose task was resolved from the worker id names the
+    // exact command for that task (every host and the CLI see the same text).
+    const { action, taskId } = (value ?? {}) as { action?: unknown; taskId?: unknown };
+    return result.ok ||
+      (request as { taskId?: unknown } | null)?.taskId !== undefined ||
+      typeof taskId !== "string" ||
+      !WORKER_ADDRESSED_ACTIONS.has(`worker.${String(action)}`)
+      ? result
+      : { ...result, error: `${result.error}; run \`${workerCommand(taskId, value)}\`` };
   }
 
   private workerOnce(request: unknown): Result<Entry<Worker>> {
@@ -1892,9 +1932,31 @@ export class WorkitCore {
    * judged against the last recorded candidate, and live staleness is
    * detected by evidence, close, resume, and full inspection, which capture.
    */
-  compactContext(taskId: string, freshness?: Freshness): Result<string> {
+  compactContext(
+    taskId: string | null,
+    freshness?: Freshness,
+    /** The base branch's task (TaskStore.originTaskEntry), whose decisions are inherited. */
+    origin: { origin: string; taskId: string } | null = null,
+  ): Result<string> {
     const root = this.contextRootError();
     if (!root.ok) return root;
+    const base = origin && this.store.readStoreTask(origin.taskId);
+    const inherited: InheritedDecisions | null =
+      base?.ok && base.data
+        ? {
+            origin: origin!.origin,
+            taskId: base.data.id,
+            // A revoked decision no longer applies to anything cut from the base.
+            decisions: base.data.decisions.filter((entry) => entry.data.revoked === null),
+          }
+        : null;
+    // No task of its own yet: only what the branch inherits.
+    if (taskId === null)
+      return success(
+        null,
+        null,
+        inherited?.decisions.length ? compactTaskContext(null, inherited) : "",
+      );
     const task = this.store.readTask(taskId);
     if (!task.ok) return task;
     const helper = this.helperTaskGuard(task.data, true);
@@ -1902,7 +1964,7 @@ export class WorkitCore {
     // Per-turn path: the cheap worktree signal, never the object-writing tree hash.
     const view = this.view(task.data, false, freshness ?? signalFreshness(this.store.root));
     if (!view.ok) return view;
-    return success(view.revision, view.workspaceRevision, compactTaskContext(view.data));
+    return success(view.revision, view.workspaceRevision, compactTaskContext(view.data, inherited));
   }
 
   private view(

package/src/core/task-store.ts

@@ -314,6 +314,70 @@ const isNewerVersion = (candidate: string, current: string): boolean => {
 };
 const validId = (value: string): boolean =>
   /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(value);
+
+const readText = (file: string): string => {
+  try {
+    return fs.readFileSync(file, "utf8");
+  } catch {
+    return "";
+  }
+};
+
+/** `<old> <new> <ident> <unix seconds> <tz>\t<message>`: new sha, seconds, message. */
+const REFLOG_LINE = /^[0-9a-f]+ ([0-9a-f]+) .* (\d+) [+-]\d{4}\t(.*)$/u;
+
+/**
+ * The branch `branch` was cut from, read from git's reflogs (no git process).
+ * Only the branch log's first line counts, and only when it is the creation
+ * entry "branch: Created from <start>": an expired, rewritten or missing log
+ * says nothing. A branch created from HEAD takes
+ * the worktree HEAD log's checkout made by that creation (same new sha, same
+ * or next second) onto the branch or one of its earlier names (`aliases`, it
+ * may have been renamed since). A remote start (`origin/develop`) is
+ * returned as written.
+ */
+const branchStart = (
+  location: StoreLocation,
+  branch: string,
+  aliases: readonly string[],
+): string | null => {
+  const first = readText(
+    path.join(path.dirname(location.dir), "logs", "refs", "heads", branch),
+  ).split("\n", 1)[0];
+  // A "Created from" message only ever starts a log (git deletes the log
+  // with the branch), so the first line alone decides.
+  const created = REFLOG_LINE.exec(first);
+  const start = created && /^branch: Created from (\S+)$/u.exec(created[3])?.[1];
+  if (!created || !start) return null;
+  if (start !== "HEAD") return start;
+  if (!location.git) return null;
+  for (const line of readText(path.join(location.git.gitDir, "logs", "HEAD")).split("\n")) {
+    const entry = REFLOG_LINE.exec(line);
+    const moved = entry && /^checkout: moving from (\S+) to (\S+)$/u.exec(entry[3]);
+    const seconds = entry ? Number(entry[2]) - Number(created[2]) : -1;
+    if (
+      moved &&
+      entry[1] === created[1] &&
+      seconds >= 0 &&
+      seconds <= 1 &&
+      aliases.includes(moved[2])
+    )
+      return moved[1];
+  }
+  return null;
+};
+
+/** Whether `ref` (`refs/remotes/origin/develop`) exists, loose or packed. */
+const refExists = (common: string, ref: string): boolean =>
+  fs.existsSync(path.join(common, ref)) ||
+  readText(path.join(common, "packed-refs")).includes(` ${ref}\n`);
+
+/** Resolved bases per checkout and branch, reused while the reflogs they came
+ * from are unchanged (one entry per branch a process looked at). */
+const origins = new Map<
+  string,
+  { signature: string; name: string | null; renames: ReturnType<typeof branchRenames> }
+>();
 export const sameDirectoryIdentity = (left: string, right: string): boolean => {
   if (!path.isAbsolute(left) || !path.isAbsolute(right)) return false;
   const normalizedLeft = path.resolve(left);
@@ -658,6 +722,94 @@ export class TaskStore {
     return success(null, null, { key: key.data, bound: bound.data });
   }
 
+  /**
+   * The open task of this checkout that worker `workerId` is assigned to,
+   * whichever branch it is bound to: worker commands follow the worker, not
+   * the branch checked out now (#264). Null when no open task has it.
+   */
+  taskForWorker(workerId: unknown): Result<Id | null> {
+    if (typeof workerId !== "string" || !validId(workerId))
+      return failure(
+        "invalid_input",
+        "needs a worker id: `workit worker cancel|report <workerId>`",
+      );
+    const listed = this.listTaskIndex();
+    if (!listed.ok) return listed;
+    for (const entry of listed.data) {
+      if (entry.status === "closed") continue;
+      const loaded = this.load(entry.id);
+      if (!loaded.ok) return loaded;
+      if (loaded.data?.record.workers.some((worker) => worker.id === workerId))
+        return success(null, null, entry.id);
+    }
+    return success(null, null, null);
+  }
+
+  /**
+   * The open task whose decisions the current branch inherits: the task of
+   * the branch it was cut from (`origin/develop` counts as `develop`), in any
+   * checkout of this repository, labelled with its origin ("branch develop").
+   * Null off a branch, or when git's reflogs do not name a base.
+   */
+  originTaskEntry(): Result<{ origin: string; entry: TaskIndexEntry } | null> {
+    const key = this.currentKey();
+    const location = this.location();
+    const branch = key.ok ? key.data.branch : null;
+    if (!branch || !location.ok) return success(null, null, null);
+    const common = path.dirname(location.data.dir);
+    const heads = path.join(common, "logs", "refs", "heads");
+    const headLog = location.data.git ? path.join(location.data.git.gitDir, "logs", "HEAD") : "";
+    // Per-turn path: reading a long HEAD log and every branch log costs tens
+    // of ms, so the resolution is reused until one of these files changes.
+    const signatures = [
+      path.join(heads, branch),
+      headLog,
+      heads,
+      path.join(common, "packed-refs"),
+    ].map((file) => fileSignature(file) ?? "-");
+    const slot = `${location.data.dir}\0${headLog}\0${branch}`;
+    let resolved = origins.get(slot);
+    if (resolved?.signature !== signatures.join("|")) {
+      const renames = branchRenames(location.data);
+      // The branch's earlier names, newest first: a rename keeps its log.
+      const aliases = [branch];
+      for (const rename of renames.toReversed())
+        if (rename.to === aliases.at(-1)) aliases.push(rename.from);
+      const start = branchStart(location.data, branch, aliases);
+      const slash = start?.indexOf("/") ?? -1;
+      // `origin/develop` is the remote's `develop`: strip the remote only for
+      // a remote-tracking ref or a configured remote, never for a local
+      // branch or tag that has a slash in its name.
+      const remote =
+        slash > 0 &&
+        !refExists(common, `refs/heads/${start}`) &&
+        (refExists(common, `refs/remotes/${start}`) ||
+          readText(path.join(common, "config")).includes(`[remote "${start!.slice(0, slash)}"]`));
+      const name = start && (remote ? start.slice(slash + 1) : start);
+      // Logs only grow (their size is in the signature), so no racy check.
+      resolved = {
+        signature: signatures.join("|"),
+        name: name && !aliases.includes(name) ? name : null,
+        renames,
+      };
+      origins.set(slot, resolved);
+    }
+    const entry = resolved.name ? this.openTasksForKey(resolved.name, resolved.renames) : null;
+    if (entry && !entry.ok) return entry;
+    return success(
+      null,
+      null,
+      entry?.data[0] ? { origin: `branch ${resolved.name}`, entry: entry.data[0] } : null,
+    );
+  }
+
+  /** The record of an indexed task (`taskId` from the index) in any checkout of
+   * this store: read-only, no binding check. */
+  readStoreTask(taskId: Id): Result<TaskRecord | null> {
+    const loaded = this.load(taskId);
+    return loaded.ok ? success(null, null, loaded.data?.record ?? null) : loaded;
+  }
+
   // -------------------------------------------------------------------------
   // writes
 
@@ -1442,11 +1594,14 @@ export class TaskStore {
    * task follows its branch through `git branch -m`: it counts for the new
    * name, and a branch created later under the old name starts fresh.
    */
-  private openTasksForKey(key: string): Result<TaskIndexEntry[]> {
+  private openTasksForKey(
+    key: string,
+    known?: ReturnType<typeof branchRenames>,
+  ): Result<TaskIndexEntry[]> {
     const all = this.listStoreIndex();
     if (!all.ok) return all;
-    const location = this.location();
-    const renames = location.ok ? branchRenames(location.data) : [];
+    const location = known ? null : this.location();
+    const renames = known ?? (location?.ok ? branchRenames(location.data) : []);
     return success(
       null,
       null,

package/src/hooks/context.ts

@@ -74,6 +74,13 @@ export const currentTaskEntry = (
  * CLI (`workit_cli`, which creates implicit tasks) are tooling, not
  * conversations.
  */
+/** Whether a host conversation other than `session` is bound to the task. */
+const otherConversation = (entry: TaskIndexEntry, session: SessionHandle): boolean =>
+  entry.sessions.some(
+    (item) =>
+      item.host !== "workit_cli" && !(item.host === session.host && item.handle === session.handle),
+  );
+
 const implicitTaskEntry = (
   store: TaskStore,
   entries: TaskIndexEntry[],
@@ -81,13 +88,7 @@ const implicitTaskEntry = (
 ): TaskIndexEntry | null => {
   const open = entries.filter(
     (entry) =>
-      entry.key !== null &&
-      entry.status !== "closed" &&
-      !entry.sessions.some(
-        (item) =>
-          item.host !== "workit_cli" &&
-          !(item.host === session.host && item.handle === session.handle),
-      ),
+      entry.key !== null && entry.status !== "closed" && !otherConversation(entry, session),
   );
   if (open.length === 0) return null;
   const key = store.currentKey();
@@ -174,23 +175,37 @@ export function sessionCompactContext(
   const entry =
     currentTaskEntry(listed.data, session, selection) ??
     implicitTaskEntry(store, listed.data, session);
-  return entry ? entryCompactContext(store, entry, session, context) : null;
+  return entryCompactContext(store, entry, session, context);
 }
 
 function entryCompactContext(
   store: TaskStore,
-  entry: TaskIndexEntry,
+  entry: TaskIndexEntry | null,
   session: SessionHandle,
   context: OperationContext,
 ): string | null {
+  // The task of the branch this one was cut from: its decisions stay in view
+  // (labelled with their origin) instead of vanishing on a switch. Another
+  // conversation's task is never injected.
+  const found = store.originTaskEntry();
+  const origin =
+    found.ok &&
+    found.data &&
+    found.data.entry.id !== entry?.id &&
+    !otherConversation(found.data.entry, session)
+      ? found.data
+      : null;
+  if (!entry && !origin) return null;
   const workspace = store.readWorkspace();
-  if (!workspace.ok || !workspace.data) return null;
+  if (!workspace.ok || (entry && !workspace.data)) return null;
   const slot = `${store.root}\0${session.host}\0${session.handle}`;
   const key = canonicalJson({
-    task: entry.id,
-    revision: entry.revision,
-    file: entry.file,
-    workspace: workspace.data.revision,
+    task: entry?.id ?? null,
+    revision: entry?.revision ?? null,
+    file: entry?.file ?? null,
+    // The origin task's log signature changes with every write to it.
+    origin: origin && origin.entry.file,
+    workspace: workspace.data?.revision ?? null,
     caller: context.caller,
     workerId: context.workerId ?? null,
     capabilities: context.capabilities,
@@ -205,18 +220,22 @@ function entryCompactContext(
     (hit.signal === null || hit.signal === recentSignal(store.root))
   )
     return hit.value;
-  const task = store.readTask(entry.id);
-  if (!task.ok) return null;
+  const task = entry ? store.readTask(entry.id) : null;
+  if (task && !task.ok) return null;
   const freshness: Freshness = { mode: "signal", current: () => recentSignal(store.root) };
-  const observed = task.data.evidence.some(isObservedCheck);
-  const files = task.data.decisions.flatMap((decision) =>
+  const observed = task?.data.evidence.some(isObservedCheck) ?? false;
+  const files = (task?.data.decisions ?? []).flatMap((decision) =>
     decision.data.binding.contentRefs.flatMap((ref) =>
       ref.kind === "file" ? [path.resolve(store.root, ref.path)] : [],
     ),
   );
   const observedFiles = filesKey(files);
-  const compact = new WorkitCore(store, context).compactContext(entry.id, freshness);
-  if (!compact.ok) return null;
+  const compact = new WorkitCore(store, context).compactContext(
+    entry?.id ?? null,
+    freshness,
+    origin && { origin: origin.origin, taskId: origin.entry.id },
+  );
+  if (!compact.ok || !compact.data) return null;
   cache.delete(slot);
   cache.set(slot, {
     key,
@@ -264,9 +283,12 @@ export const sessionContextText = (
     const entry =
       currentTaskEntry(listed.data, session, descriptor.context.task) ??
       implicitTaskEntry(store, listed.data, session);
-    const text = entry
-      ? entryCompactContext(store, entry, session, hookOperationContext(input, descriptor))
-      : null;
+    const text = entryCompactContext(
+      store,
+      entry,
+      session,
+      hookOperationContext(input, descriptor),
+    );
     if (text) compact = `\n<workit-task-context>${text}</workit-task-context>`;
     if (options.offer) offer = unfinishedTaskOffer(listed.data, session, entry?.id ?? null);
   } catch {

package/src/hooks/handle.ts

@@ -6,6 +6,7 @@ import {
   turnContextText,
 } from "./context";
 import type { HostDescriptor, Support } from "./descriptor";
+import { recordIssuedSession } from "../host-session";
 import { shellPolicy } from "./policy";
 import {
   callKey,
@@ -100,6 +101,9 @@ const subagentStartText = (
   const readOnly = `Workit observed ${who} as read-only/agent-guided.`;
   if (role !== "judge" || !event.agentId) return readOnly;
   const own = subagentSession(session, event.agentId);
+  // `ledger verdict` accepts `<lead>:<agent id>` only when this hook issued it.
+  // (An isolated judge's text is rebuilt with cwd "": the hook's own cwd then.)
+  if (session) recordIssuedSession(input.cwd || process.cwd(), session, own);
   return `${readOnly} Its own Workit session is ${own}: record verdicts with \`workit ledger verdict <result> --session ${own} ...\` so the ledger tells it apart from the author.`;
 };
 

package/src/hooks/hosts/codex.ts

@@ -362,5 +362,5 @@ export const codexAdapter: HostAdapter = {
   },
   render,
   addendum: (input) =>
-    `<workit-codex-mutations>Codex MCP is read-only: unattested callers cannot mutate. Run workit verbs with the workit CLI on the shell (node_modules/.bin/workit, or npx -y @brainervirus/workit-cli): check, git branch|commit|push, pr, ci, stack, ledger, handoff; task-family mutations take --json${input.session.id ? ` --actor ${input.session.id}` : ""}. workit acts as this thread (CODEX_THREAD_ID${input.session.id ? `=${input.session.id}` : ""}) unless WORKIT_SESSION_ID is set. A verifier or reviewer records workit ledger verdict under its own session, never the author's: a workit-verifier or workit-reviewer agent uses the --session its SubagentStart context names; any other uses one the lead assigns (WORKIT_HOST=codex_cli WORKIT_SESSION_ID=<lead>-v<n>). Merge and release need a workspace grant (workit grant show); a question answer is not host permission.</workit-codex-mutations>`,
+    `<workit-codex-mutations>Codex MCP is read-only: unattested callers cannot mutate. Run workit verbs with the workit CLI on the shell (node_modules/.bin/workit, or npx -y @brainervirus/workit-cli): check, git branch|commit|push, pr, ci, stack, ledger, handoff; task-family mutations take --json${input.session.id ? ` --actor ${input.session.id}` : ""}. workit acts as this thread (CODEX_THREAD_ID${input.session.id ? `=${input.session.id}` : ""}) unless WORKIT_SESSION_ID is set. A verifier or reviewer records workit ledger verdict under its own session, never the author's: a workit-verifier or workit-reviewer agent uses the --session its SubagentStart context names; any other passes --as verifier (an id derived from its own thread). A hand-minted id such as <lead>-v1 is refused as forged_session. Merge and release need a workspace grant (workit grant show); a question answer is not host permission.</workit-codex-mutations>`,
 };

package/src/host-session.ts

@@ -7,6 +7,10 @@
 //   - Pi: PI_SESSION_ID (the bash tool exposes the Pi session id);
 //   - Codex CLI and Desktop: CODEX_THREAD_ID (the thread id hooks get as session_id).
 // Cursor puts no conversation id in its shell; its hook names the id to use.
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { resolveStore } from "./store/paths";
 
 export type HostSession = { host: string | null; session: string | null };
 
@@ -51,3 +55,188 @@ export function hostSessionFromEnv(env: NodeJS.ProcessEnv): HostSession {
   }
   return inner ? { host: inner.host, session: inner.session } : { host: declared, session: null };
 }
+
+/**
+ * Where this shell's session comes from:
+ *   - `derived`: the host's own shell variable (OPENCODE_SESSION_ID,
+ *     PI_SESSION_ID, CODEX_THREAD_ID), which a caller cannot replace by
+ *     exporting WORKIT_SESSION_ID;
+ *   - `declared`: a host that puts no id in the shell but names itself
+ *     (WORKIT_HOST, e.g. Claude Code's SessionStart export) declares it in
+ *     WORKIT_SESSION_ID;
+ *   - `none`: no host at all (CI, a plain terminal, Cursor's prefixed
+ *     commands): whatever session the caller names is only declared.
+ */
+export type RealSession = HostSession & { kind: "derived" | "declared" | "none" };
+
+export function realHostSession(env: NodeJS.ProcessEnv): RealSession {
+  for (const [key, host] of HOST_SESSION_VARS) {
+    const session = env[key]?.trim();
+    if (session) return { host: host(env), session, kind: "derived" };
+  }
+  const declared = hostSessionFromEnv(env);
+  const hosted = declared.host !== null && declared.host !== "cli";
+  return { ...declared, kind: hosted ? "declared" : "none" };
+}
+
+// Ids a SubagentStart hook gave a lead's subagents (`<lead>:<agent id>`): one
+// empty file per id under `<store>/hooks/issued/<lead hash>/`, so concurrent
+// hooks never lose each other's write, bounded per lead.
+const ISSUED_PER_LEAD = 64;
+
+/**
+ * Written into each issued-id file. A hook bundle that contains this string
+ * records issued ids; `workit doctor` looks for it in the installed Claude
+ * Code and Codex hooks to catch a plugin older than the CLI.
+ */
+export const ISSUED_SESSIONS_MARKER = "workit-issued-sessions/1";
+
+const hash = (value: string): string =>
+  createHash("sha256").update(value).digest("hex").slice(0, 32);
+
+const issuedRoot = (cwd: string): string | null => {
+  const location = resolveStore(cwd);
+  return location instanceof Error ? null : path.join(location.dir, "hooks", "issued");
+};
+
+const issuedDir = (cwd: string, lead: string): string | null => {
+  const root = issuedRoot(cwd);
+  return root === null ? null : path.join(root, hash(lead));
+};
+
+/** No hook in this workspace has ever recorded an issued id (an older plugin hook, most likely). */
+const noIssuedRecord = (cwd: string | undefined): boolean => {
+  if (cwd === undefined) return false;
+  try {
+    const root = issuedRoot(cwd);
+    return root !== null && !fs.existsSync(root);
+  } catch {
+    return false;
+  }
+};
+
+/** Per host: how to update the plugin whose SubagentStart hook issues ids. */
+const PLUGIN_UPDATE: Readonly<Record<string, string>> = {
+  claude_code: "claude plugin marketplace update workit && claude plugin update workit@workit",
+  codex: "codex plugin remove workit@workit && codex plugin add workit@workit",
+};
+
+/** Remember that a SubagentStart hook issued `issued` to a subagent of `lead`. Fails open. */
+export function recordIssuedSession(cwd: string, lead: string, issued: string): void {
+  try {
+    const dir = issuedDir(cwd, lead);
+    if (!dir) return;
+    fs.mkdirSync(dir, { recursive: true });
+    const own = hash(issued);
+    fs.writeFileSync(path.join(dir, own), ISSUED_SESSIONS_MARKER);
+    const entries = fs.readdirSync(dir);
+    if (entries.length <= ISSUED_PER_LEAD) return;
+    // Oldest first; the id just issued is never the one pruned.
+    const byAge = entries
+      .filter((name) => name !== own)
+      .map((name) => ({ name, at: fs.statSync(path.join(dir, name)).mtimeMs }))
+      .toSorted((a, b) => a.at - b.at);
+    for (const { name } of byAge.slice(0, entries.length - ISSUED_PER_LEAD))
+      fs.rmSync(path.join(dir, name), { force: true });
+  } catch {
+    // Fail open: an unrecorded id is refused later, never a broken hook.
+  }
+}
+
+const wasIssued = (cwd: string | undefined, lead: string, claimed: string): boolean => {
+  if (cwd === undefined) return false;
+  try {
+    const dir = issuedDir(cwd, lead);
+    return dir !== null && fs.existsSync(path.join(dir, hash(claimed)));
+  } catch {
+    return false;
+  }
+};
+
+const leadOf = (session: string): string => session.slice(0, session.lastIndexOf(":"));
+
+/**
+ * Hosts whose child sessions run their own shell with their own host session
+ * id: a child proves itself from its own shell, so a lead never mints a child id.
+ */
+const OWN_CHILD_SHELL = new Set(["opencode", "pi"]);
+
+const SESSION_UNSAFE = /[^A-Za-z0-9_.:@/+-]/g;
+
+/**
+ * The host-derived identity of a child session: `<lead>:<child>`, the shape
+ * Claude Code's SubagentStart hook gives a subagent. The child's own id is
+ * kept whole (it is what the host vouches for); the lead part is trimmed to
+ * fit the ledger's 128-character session grammar.
+ */
+export function childSessionId(lead: string, child: string): string {
+  const leaf = child.replace(SESSION_UNSAFE, "-").slice(-120);
+  const prefix = lead.replace(SESSION_UNSAFE, "-").slice(0, 127 - leaf.length);
+  return prefix ? `${prefix}:${leaf}` : leaf;
+}
+
+export type SessionClaimRefusal = { error: string; unblock: string };
+
+/**
+ * Whether `claimed` may act as this shell's session (`cwd` locates the
+ * workspace's record of hook-issued ids):
+ *   - no host session (CI, a plain terminal): any id; `--session X` and
+ *     WORKIT_SESSION_ID=X are the same declaration;
+ *   - the shell's own session (a declared `<lead>:<x>` on Claude Code only
+ *     when its SubagentStart hook issued it);
+ *   - on a host that sets the id, `<lead>:<this session>`: a child naming its
+ *     own host session;
+ *   - `<this session>:<agent id>` only when this lead's SubagentStart hook
+ *     issued it (Claude Code, Codex).
+ * Anything else is a forged id: a verdict recorded under it would make author
+ * is not verifier a naming convention.
+ */
+export function sessionClaimRefusal(
+  env: NodeJS.ProcessEnv,
+  claimed: string,
+  cwd?: string,
+): SessionClaimRefusal | null {
+  const real = realHostSession(env);
+  const host = family(real.host);
+  // A host that always sets its own variable, named without it: the variable
+  // was removed (`env -u OPENCODE_SESSION_ID`), so nothing vouches for the id.
+  if (real.kind !== "derived" && host !== null && HOST_SET_VARIABLE[host])
+    return {
+      error: `forged_session: WORKIT_HOST names ${real.host}, but its own ${HOST_SET_VARIABLE[host]} is not in this shell, so ${claimed} cannot be checked`,
+      unblock: `record the verdict from the ${real.host} session's own shell, where ${HOST_SET_VARIABLE[host]} is set`,
+    };
+  if (real.kind === "none" || !real.session) return null;
+  let issuedClaim = false;
+  if (claimed === real.session) {
+    const declaredChild =
+      real.kind === "declared" && host === "claude_code" && claimed.includes(":");
+    if (!declaredChild || wasIssued(cwd, leadOf(claimed), claimed)) return null;
+    issuedClaim = true;
+  } else if (real.kind === "derived" && claimed.endsWith(`:${real.session}`)) return null;
+  else if (claimed.startsWith(`${real.session}:`)) {
+    if (wasIssued(cwd, real.session, claimed)) return null;
+    issuedClaim = true;
+  }
+  const error = `forged_session: ${claimed} is neither this shell's session (${real.session}) nor an id its host issued to a child of it`;
+  // A well-formed subagent id, but no hook here ever recorded one: the hook
+  // most likely predates this CLI (CLI and plugin update separately).
+  if (issuedClaim && noIssuedRecord(cwd) && host !== null && PLUGIN_UPDATE[host])
+    return {
+      error: `${error}; no SubagentStart hook in this workspace has recorded an issued id`,
+      unblock: `the workit plugin hook is probably older than this CLI and does not record the ids it issues: update the plugin (${PLUGIN_UPDATE[host]}), then relaunch the verifier so its SubagentStart runs the new hook (workit doctor checks this as hook_issued_sessions)`,
+    };
+  const ownChildShell = host !== null && OWN_CHILD_SHELL.has(host);
+  return {
+    error,
+    unblock: ownChildShell
+      ? `record the verdict from the verifier's own ${host === "pi" ? "Pi worker" : "OpenCode child session"} shell, where WORKIT_SESSION_ID is already set; never set WORKIT_SESSION_ID or --session by hand`
+      : "never name a session yourself: spawn a verifier or reviewer subagent and pass exactly the --session its SubagentStart context names, or pass --as verifier",
+  };
+}
+
+/** Hosts that always put their own session variable in the agent's shell. */
+const HOST_SET_VARIABLE: Readonly<Record<string, string>> = {
+  opencode: "OPENCODE_SESSION_ID",
+  pi: "PI_SESSION_ID",
+  codex: "CODEX_THREAD_ID",
+};

package/src/ledger.ts

@@ -1140,10 +1140,31 @@ export function authorSessions(
   return sessions;
 }
 
+/** Where each host's verifier session comes from, for refusal hints. */
+const HOST_DERIVED_SESSIONS =
+  "Claude Code, Codex and Cursor: `--session <lead>:<agent id>` from the SubagentStart hook; OpenCode child sessions and Pi workers: WORKIT_SESSION_ID=<lead>:<child> already set in their shell";
+
+/** Whether `derived` is a host-derived `<lead>:<bare>` id for the bare host session `bare`. */
+const derivesFrom = (derived: string, bare: string): boolean =>
+  !bare.includes(":") && derived.endsWith(`:${bare}`);
+
+/**
+ * Whether `session` is one of the authors: the same id, or one is a bare host
+ * session and the other its derived `<lead>:<session>` form (an OpenCode
+ * child that committed as `<lead>:<child>` and judges as `<child>` is still
+ * the author). Two derived ids never match on a shared last segment.
+ */
+const authoredBy = (authors: Set<string>, session: string): boolean => {
+  if (authors.has(session)) return true;
+  for (const author of authors)
+    if (derivesFrom(author, session) || derivesFrom(session, author)) return true;
+  return false;
+};
+
 const independenceReasons = (row: ReadRow, authors: Set<string>): RejectReason[] => {
   const reasons: RejectReason[] = [];
   if (!row.actor.session) reasons.push("no_session");
-  else if (authors.has(row.actor.session)) reasons.push("author_session");
+  else if (authoredBy(authors, row.actor.session)) reasons.push("author_session");
   if (row.self === true && !reasons.includes("no_session")) reasons.push("self");
   return reasons;
 };
@@ -1687,15 +1708,16 @@ export function recordVerdict(
     head: key.head,
   });
   const authoring = [session, input.derivedFrom].find(
-    (candidate): candidate is string => typeof candidate === "string" && authors.has(candidate),
+    (candidate): candidate is string =>
+      typeof candidate === "string" && authoredBy(authors, candidate),
   );
   if (!self && authoring)
     return err(
       "blocked",
       `author_verdict: session ${authoring} authored ${branch}; a verdict must come from a different session`,
       input.derivedFrom === undefined
-        ? "have a non-author session record the verdict: spawn a verifier with its own WORKIT_SESSION_ID=<lead>-v<n> (Claude Code: subagents get one from the SubagentStart hook); or, as the author, pass --self (self-reviewed, never accepted)"
-        : "run the verifier as a separate session: the lead spawns it with its own WORKIT_SESSION_ID (Claude Code: subagents get one from the SubagentStart hook)",
+        ? `have a non-author session record the verdict: spawn a verifier subagent, which gets its own host-derived session (${HOST_DERIVED_SESSIONS}); or, as the author, pass --self (self-reviewed, never accepted)`
+        : `run the verifier as a separate session: spawn a verifier subagent, which gets its own host-derived session (${HOST_DERIVED_SESSIONS})`,
     );
   const link = checkSupersede(context, "verdict", { self, kind, branch });
   if (!link.ok) return link;