@brainervirus/workit-core 8.9.0 → 8.9.1

package/package.json

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

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 {