@brainervirus/workit-cursor 8.9.0 → 8.10.0

package/dist/mcp-server.js

@@ -18442,64 +18442,11 @@ function acquireFileLockSync(targetPath, options) {
     }
   }
 }
-// packages/workit-core/src/host-session.ts
-var HOST_SESSION_VARS = [
-  ["OPENCODE_SESSION_ID", () => "opencode"],
-  ["PI_SESSION_ID", () => "pi"],
-  [
-    "CODEX_THREAD_ID",
-    (env) => env.CODEX_INTERNAL_ORIGINATOR_OVERRIDE === "Codex Desktop" || env.CODEX_ELECTRON_RESOURCES_PATH ? "codex_desktop" : "codex_cli"
-  ]
-];
-var family = (host) => host?.replace(/_(?:cli|desktop)$/, "") ?? null;
-function hostSessionFromEnv(env) {
-  const value = (key) => env[key]?.trim() || null;
-  let inner = null;
-  for (const [key, host] of HOST_SESSION_VARS) {
-    const session = value(key);
-    if (session) {
-      inner = { host: host(env), session };
-      break;
-    }
-  }
-  const declared = value("WORKIT_HOST");
-  if (env.WORKIT_SESSION_ID !== undefined) {
-    const inherited = inner !== null && declared !== null && family(declared) !== family(inner.host);
-    if (!inherited)
-      return { host: declared, session: value("WORKIT_SESSION_ID") };
-  }
-  return inner ? { host: inner.host, session: inner.session } : { host: declared, session: null };
-}
-
-// packages/workit-core/src/core/package-root.ts
-import { existsSync } from "node:fs";
-import path3 from "node:path";
-import { fileURLToPath } from "node:url";
-var packageRoot = () => {
-  let dir = path3.dirname(fileURLToPath(import.meta.url));
-  while (true) {
-    const parent = path3.dirname(dir);
-    if (existsSync(path3.join(dir, "package.json")) || parent === dir)
-      return dir;
-    dir = parent;
-  }
-};
-var assetRoot = () => {
-  const root = packageRoot();
-  const assets = path3.join(root, "assets");
-  return existsSync(assets) ? assets : root;
-};
-
-// packages/workit-core/src/core/store-lock.ts
-import { spawnSync as spawnSync2 } from "node:child_process";
-import fs5 from "node:fs";
-import { hostname } from "node:os";
-
 // packages/workit-core/src/store/paths.ts
 import { spawnSync } from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
 import fs4 from "node:fs";
-import path4 from "node:path";
+import path3 from "node:path";
 var NOT_A_REPO = /not a git repository \(or any (of the parent directories|parent up to)/u;
 var gitRun = (cwd, args) => {
   const run = spawnSync("git", args, {
@@ -18541,14 +18488,14 @@ var DISCOVERY_ENV = [
 ];
 var isGitDir = (dir) => {
   try {
-    return fs4.statSync(path4.join(dir, "HEAD")).isFile() && fs4.statSync(path4.join(dir, "objects")).isDirectory() && fs4.statSync(path4.join(dir, "refs")).isDirectory();
+    return fs4.statSync(path3.join(dir, "HEAD")).isFile() && fs4.statSync(path3.join(dir, "objects")).isDirectory() && fs4.statSync(path3.join(dir, "refs")).isDirectory();
   } catch {
     return false;
   }
 };
 var reftableRefs = (common) => {
   try {
-    return /^\s*refstorage\s*=\s*reftable\s*$/imu.test(fs4.readFileSync(path4.join(common, "config"), "utf8"));
+    return /^\s*refstorage\s*=\s*reftable\s*$/imu.test(fs4.readFileSync(path3.join(common, "config"), "utf8"));
   } catch {
     return false;
   }
@@ -18568,7 +18515,7 @@ function fastGit(root) {
     if (device !== null && stat.dev !== device)
       return { kind: "none" };
     device = stat.dev;
-    const dotGit = path4.join(dir, ".git");
+    const dotGit = path3.join(dir, ".git");
     let entry = null;
     try {
       entry = fs4.statSync(dotGit);
@@ -18589,19 +18536,19 @@ function fastGit(root) {
         const match = /^gitdir: (.+)$/mu.exec(text);
         if (!match)
           return null;
-        gitDir = path4.resolve(dir, match[1].trim());
+        gitDir = path3.resolve(dir, match[1].trim());
       } else
         return null;
-      if (!fs4.existsSync(path4.join(gitDir, "HEAD")))
+      if (!fs4.existsSync(path3.join(gitDir, "HEAD")))
         return null;
     } else if (isGitDir(dir))
       gitDir = dir;
     if (gitDir) {
       let common = gitDir;
       try {
-        common = path4.resolve(gitDir, fs4.readFileSync(path4.join(gitDir, "commondir"), "utf8").trim());
+        common = path3.resolve(gitDir, fs4.readFileSync(path3.join(gitDir, "commondir"), "utf8").trim());
       } catch {}
-      if (!fs4.existsSync(path4.join(common, "objects")))
+      if (!fs4.existsSync(path3.join(common, "objects")))
         return null;
       return {
         kind: "repo",
@@ -18611,26 +18558,26 @@ function fastGit(root) {
         reftable: reftableRefs(common)
       };
     }
-    const parent = path4.dirname(dir);
+    const parent = path3.dirname(dir);
     if (parent === dir)
       return { kind: "none" };
     dir = parent;
   }
 }
 function resolveStore(root) {
-  root = path4.resolve(root);
+  root = path3.resolve(root);
   let directory = false;
   try {
     directory = fs4.statSync(root).isDirectory();
   } catch {}
   if (!directory)
-    return { dir: path4.join(root, ".workit"), shared: false, top: null };
+    return { dir: path3.join(root, ".workit"), shared: false, top: null };
   const fast = fastGit(root);
   if (fast?.kind === "none")
-    return { dir: path4.join(root, ".workit"), shared: false, top: null };
+    return { dir: path3.join(root, ".workit"), shared: false, top: null };
   if (fast?.kind === "repo")
     return {
-      dir: path4.join(fast.common, "workit"),
+      dir: path3.join(fast.common, "workit"),
       shared: true,
       top: fast.top,
       git: { gitDir: fast.gitDir, top: fast.top, reftable: fast.reftable }
@@ -18640,20 +18587,20 @@ function resolveStore(root) {
   if (run.ok && common) {
     const top = gitRun(root, ["rev-parse", "--path-format=absolute", "--show-toplevel"]);
     return {
-      dir: path4.join(real(path4.resolve(root, common)), "workit"),
+      dir: path3.join(real(path3.resolve(root, common)), "workit"),
       shared: true,
       top: top.ok && top.stdout.trim() ? real(top.stdout.trim()) : null
     };
   }
   if (run.missing || !run.ok && NOT_A_REPO.test(run.stderr))
-    return { dir: path4.join(root, ".workit"), shared: false, top: null };
+    return { dir: path3.join(root, ".workit"), shared: false, top: null };
   return new Error(`cannot locate the workit store: git rev-parse failed (${run.stderr.trim().split(`
 `)[0] || "no output"}); fix the repository (git status should work here)`);
 }
 var rebasingBranch = (gitDir) => {
   for (const state of ["rebase-merge", "rebase-apply"]) {
     try {
-      const ref = fs4.readFileSync(path4.join(gitDir, state, "head-name"), "utf8").trim();
+      const ref = fs4.readFileSync(path3.join(gitDir, state, "head-name"), "utf8").trim();
       const match = /^refs\/heads\/(.+)$/u.exec(ref);
       if (match)
         return match[1];
@@ -18668,7 +18615,7 @@ function resolveTaskKey(root, location) {
   if (location.git && !location.git.reftable) {
     let head = "";
     try {
-      head = fs4.readFileSync(path4.join(location.git.gitDir, "HEAD"), "utf8").trim();
+      head = fs4.readFileSync(path3.join(location.git.gitDir, "HEAD"), "utf8").trim();
     } catch {}
     const ref = /^ref: refs\/heads\/(.+)$/u.exec(head);
     if (ref && ref[1] !== ".invalid")
@@ -18699,7 +18646,7 @@ function resolveTaskKey(root, location) {
   return { key: `detached-${shortHash(real(worktree))}`, kind: "detached", branch: null };
 }
 function checkoutRootOf(root, location) {
-  const resolved = path4.resolve(root);
+  const resolved = path3.resolve(root);
   let canonical = resolved;
   try {
     canonical = fs4.realpathSync(resolved);
@@ -18730,13 +18677,13 @@ function branchRenames(location) {
     }
     for (const entry of entries)
       if (entry.isDirectory())
-        walk(path4.join(dir, entry.name));
+        walk(path3.join(dir, entry.name));
       else
-        files.push(path4.join(dir, entry.name));
+        files.push(path3.join(dir, entry.name));
   };
-  walk(path4.join(path4.dirname(location.dir), "logs", "refs", "heads"));
+  walk(path3.join(path3.dirname(location.dir), "logs", "refs", "heads"));
   if (location.git)
-    files.push(path4.join(location.git.gitDir, "logs", "HEAD"));
+    files.push(path3.join(location.git.gitDir, "logs", "HEAD"));
   const seen = new Set;
   const renames = [];
   for (const file of files) {
@@ -18771,11 +18718,63 @@ var checkoutSlug = (root) => {
   let canonical = real(root);
   if (process.platform === "win32")
     canonical = canonical.toLowerCase();
-  const base = path4.basename(canonical).replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 40) || "root";
+  const base = path3.basename(canonical).replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 40) || "root";
   return `${base}-${shortHash(canonical)}`;
 };
 
+// packages/workit-core/src/host-session.ts
+var HOST_SESSION_VARS = [
+  ["OPENCODE_SESSION_ID", () => "opencode"],
+  ["PI_SESSION_ID", () => "pi"],
+  [
+    "CODEX_THREAD_ID",
+    (env) => env.CODEX_INTERNAL_ORIGINATOR_OVERRIDE === "Codex Desktop" || env.CODEX_ELECTRON_RESOURCES_PATH ? "codex_desktop" : "codex_cli"
+  ]
+];
+var family = (host) => host?.replace(/_(?:cli|desktop)$/, "") ?? null;
+function hostSessionFromEnv(env) {
+  const value = (key) => env[key]?.trim() || null;
+  let inner = null;
+  for (const [key, host] of HOST_SESSION_VARS) {
+    const session = value(key);
+    if (session) {
+      inner = { host: host(env), session };
+      break;
+    }
+  }
+  const declared = value("WORKIT_HOST");
+  if (env.WORKIT_SESSION_ID !== undefined) {
+    const inherited = inner !== null && declared !== null && family(declared) !== family(inner.host);
+    if (!inherited)
+      return { host: declared, session: value("WORKIT_SESSION_ID") };
+  }
+  return inner ? { host: inner.host, session: inner.session } : { host: declared, session: null };
+}
+var OWN_CHILD_SHELL = new Set(["opencode", "pi"]);
+
+// packages/workit-core/src/core/package-root.ts
+import { existsSync } from "node:fs";
+import path4 from "node:path";
+import { fileURLToPath } from "node:url";
+var packageRoot = () => {
+  let dir = path4.dirname(fileURLToPath(import.meta.url));
+  while (true) {
+    const parent = path4.dirname(dir);
+    if (existsSync(path4.join(dir, "package.json")) || parent === dir)
+      return dir;
+    dir = parent;
+  }
+};
+var assetRoot = () => {
+  const root = packageRoot();
+  const assets = path4.join(root, "assets");
+  return existsSync(assets) ? assets : root;
+};
+
 // packages/workit-core/src/core/store-lock.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+import fs5 from "node:fs";
+import { hostname } from "node:os";
 var metadataLockSchema = object2({
   pid: number2().int().nonnegative().safe(),
   processStart: string2().nullable(),
@@ -19409,6 +19408,38 @@ var isNewerVersion = (candidate, current) => {
   return false;
 };
 var validId = (value) => /^[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);
+var readText = (file) => {
+  try {
+    return fs7.readFileSync(file, "utf8");
+  } catch {
+    return "";
+  }
+};
+var REFLOG_LINE = /^[0-9a-f]+ ([0-9a-f]+) .* (\d+) [+-]\d{4}\t(.*)$/u;
+var branchStart = (location, branch, aliases) => {
+  const first = readText(path6.join(path6.dirname(location.dir), "logs", "refs", "heads", branch)).split(`
+`, 1)[0];
+  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(path6.join(location.git.gitDir, "logs", "HEAD")).split(`
+`)) {
+    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;
+};
+var refExists = (common, ref) => fs7.existsSync(path6.join(common, ref)) || readText(path6.join(common, "packed-refs")).includes(` ${ref}
+`);
+var origins = new Map;
 var sameDirectoryIdentity = (left, right) => {
   if (!path6.isAbsolute(left) || !path6.isAbsolute(right))
     return false;
@@ -19661,6 +19692,66 @@ class TaskStore {
       return bound;
     return success(null, null, { key: key.data, bound: bound.data });
   }
+  taskForWorker(workerId) {
+    if (typeof workerId !== "string" || !validId(workerId))
+      return failure2("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);
+  }
+  originTaskEntry() {
+    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 = path6.dirname(location.data.dir);
+    const heads = path6.join(common, "logs", "refs", "heads");
+    const headLog = location.data.git ? path6.join(location.data.git.gitDir, "logs", "HEAD") : "";
+    const signatures = [
+      path6.join(heads, branch),
+      headLog,
+      heads,
+      path6.join(common, "packed-refs")
+    ].map((file) => fileSignature(file) ?? "-");
+    const slot = `${location.data.dir}\x00${headLog}\x00${branch}`;
+    let resolved = origins.get(slot);
+    if (resolved?.signature !== signatures.join("|")) {
+      const renames = branchRenames(location.data);
+      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;
+      const remote = slash > 0 && !refExists(common, `refs/heads/${start}`) && (refExists(common, `refs/remotes/${start}`) || readText(path6.join(common, "config")).includes(`[remote "${start.slice(0, slash)}"]`));
+      const name = start && (remote ? start.slice(slash + 1) : start);
+      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);
+  }
+  readStoreTask(taskId) {
+    const loaded = this.load(taskId);
+    return loaded.ok ? success(null, null, loaded.data?.record ?? null) : loaded;
+  }
   create(input, provenance, expectedWorkspaceRevision) {
     const value = "intent" in input ? input : {
       intent: input,
@@ -20330,12 +20421,12 @@ class TaskStore {
       return 0;
     }
   }
-  openTasksForKey(key) {
+  openTasksForKey(key, known) {
     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, all.data.filter((entry) => entry.key !== null && entry.status !== "closed").filter((entry) => (renames.length ? followRenames(entry.key, entry.boundAt ?? entry.createdAt, renames) : entry.key) === key).toSorted(oldestFirst));
   }
   openTaskForKey(key) {
@@ -23316,11 +23407,20 @@ function authorSessions(cwd, rows, branch, range = { base: null, head: null }, s
     sessions.add(session);
   return sessions;
 }
+var derivesFrom = (derived, bare) => !bare.includes(":") && derived.endsWith(`:${bare}`);
+var authoredBy = (authors, session) => {
+  if (authors.has(session))
+    return true;
+  for (const author of authors)
+    if (derivesFrom(author, session) || derivesFrom(session, author))
+      return true;
+  return false;
+};
 var independenceReasons = (row, authors) => {
   const reasons = [];
   if (!row.actor.session)
     reasons.push("no_session");
-  else if (authors.has(row.actor.session))
+  else if (authoredBy(authors, row.actor.session))
     reasons.push("author_session");
   if (row.self === true && !reasons.includes("no_session"))
     reasons.push("self");
@@ -24421,38 +24521,45 @@ var compactReference = (ref) => {
     };
   return { kind: ref.kind };
 };
-function compactTaskContext(view) {
-  const decisions = 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 = view.task.policy ? selectMethods(view.task.policy, view.capabilities).map((method) => ({
+var newestDecisionFirst = (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;
+};
+var compactDecisions = (sources) => 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),
+  origin: source.origin ?? undefined
+})) : []).slice(0, COMPACT_MAX_ITEMS);
+function compactTaskContext(view, inherited = null) {
+  const decisions = compactDecisions([
+    view && { origin: null, taskId: view.task.id, decisions: view.task.decisions },
+    inherited
+  ]);
+  const methods = 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.filter((entry) => entry.status !== "satisfied").map((entry) => entry.reason),
-    ...view.task.progress.blockers.map((entry) => entry.reason)
+    ...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)
   ])).toSorted().slice(0, COMPACT_MAX_ITEMS).map((gap) => compactText(gap, COMPACT_TEXT_BYTES));
   const context = {
-    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 (compactBytes(encoded) > COMPACT_MAX_BYTES && (context.decisions.length || context.methods.length || context.gaps.length)) {
@@ -25057,6 +25164,13 @@ var TASK_SCOPED_ACTIONS = new Set([
   "worker.cancel",
   "state.export"
 ]);
+var WORKER_ADDRESSED_ACTIONS = new Set(["worker.cancel", "worker.report"]);
+var workerCommand = (taskId, request) => {
+  const { action, workerId, reason, report } = request;
+  const rest = JSON.stringify({ reason, report });
+  const payload = rest === "{}" ? "" : ` --payload '${rest.replace(/'/gu, "'\\''")}'`;
+  return `workit worker ${String(action)} ${String(workerId)} --task ${taskId}${payload}`;
+};
 var CREATING_ACTIONS = new Set([
   "task.revise",
   "task.progress",
@@ -25307,6 +25421,17 @@ class WorkitCore {
     const root = this.contextRootError();
     if (!root.ok)
       return root;
+    const addressed = WORKER_ADDRESSED_ACTIONS.has(action);
+    const workerId = addressed ? value.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 failure2("not_found", `worker ${workerId} 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),
@@ -26013,7 +26138,9 @@ class WorkitCore {
     if (!resolved.ok)
       return resolved;
     const value = resolved.data;
-    return this.retryOmittedRevisions(value, () => this.workerOnce(value));
+    const result = this.retryOmittedRevisions(value, () => this.workerOnce(value));
+    const { action, taskId } = value ?? {};
+    return result.ok || request?.taskId !== undefined || typeof taskId !== "string" || !WORKER_ADDRESSED_ACTIONS.has(`worker.${String(action)}`) ? result : { ...result, error: `${result.error}; run \`${workerCommand(taskId, value)}\`` };
   }
   workerOnce(request) {
     const root = this.contextRootError();
@@ -26218,10 +26345,18 @@ class WorkitCore {
       requirements
     });
   }
-  compactContext(taskId, freshness) {
+  compactContext(taskId, freshness, origin = null) {
     const root = this.contextRootError();
     if (!root.ok)
       return root;
+    const base = origin && this.store.readStoreTask(origin.taskId);
+    const inherited = base?.ok && base.data ? {
+      origin: origin.origin,
+      taskId: base.data.id,
+      decisions: base.data.decisions.filter((entry) => entry.data.revoked === null)
+    } : null;
+    if (taskId === null)
+      return success(null, null, inherited?.decisions.length ? compactTaskContext(null, inherited) : "");
     const task = this.store.readTask(taskId);
     if (!task.ok)
       return task;
@@ -26231,7 +26366,7 @@ class WorkitCore {
     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));
   }
   view(task, capture = true, freshness = treeFreshness(this.store.root)) {
     const workspace = this.store.readWorkspace();