@zq-silk/yui 2.20.0 → 2.22.0

package/dist/commands/taskFactCommands.js

@@ -1,9 +1,10 @@
 import { createTaskBrief, updateTaskBrief } from "../brief/taskBrief.js";
-import { assertContextRecordReadable, resolveContextReader } from "../context/taskContext.js";
+import { assertTaskReadable, resolveContextReader } from "../context/taskContext.js";
 import { taskRecordList } from "./taskContextCommand.js";
 import { materialize } from "../context/taskContext.js";
 import { enqueueWork } from "../coordination/workMailboxQueue.js";
 import { createDecision, supersedeDecision } from "../decision/decision.js";
+import { readDigest } from "../output/boundedRead.js";
 import { dataError, usageError } from "../errors/cliError.js";
 import { createMilestone } from "../milestone/milestone.js";
 import { assertTaskOpen, clock, exactPositionals, leaderActionEventPayload, leaderMailbox, notifyMailbox, output, parseMultiValueTail, parseTail, presentTime, recordTaskEvent, requiredOption, requiredText, requireTask, taskActor, taskMailbox, taskRef } from "./taskCommandSupport.js";
@@ -15,7 +16,7 @@ export function taskBriefCommand(args, store, options) {
         exactPositionals(rest, 1, "Task brief show usage: yui task brief show <task>.");
         const { task, brief, writeGuard, phase } = store.readTransaction(reader => {
             const task = requireTask(reader, rest[0]);
-            assertContextRecordReadable(reader, task.id, "task-brief", task.id, options.environment);
+            assertTaskReadable(reader, task.id, options.environment);
             const caller = resolveContextReader(reader, options.environment ?? {});
             const shared = caller === undefined || caller.roleName === "leader";
             return { task, brief: reader.getTaskBrief(task.id),
@@ -107,6 +108,18 @@ export function taskBriefCommand(args, store, options) {
         ? "Task brief command is required."
         : `Unknown command: task brief ${command}`);
 }
+function decisionReceipt(decision) {
+    // A short saved value lets the caller inspect the actual effect without
+    // another read. Bound the complete JSON record, including title/reason.
+    const contentOmitted = Buffer.byteLength(JSON.stringify(decision)) > 2048;
+    const value = contentOmitted ? {
+        id: decision.id, taskId: decision.taskId, status: decision.status,
+        createdAt: decision.createdAt, updatedAt: decision.updatedAt
+    } : decision;
+    return { taskId: decision.taskId, effect: "saved", contentOmitted, decision: { ...value,
+            digest: readDigest(decision), rationaleBytes: Buffer.byteLength(decision.rationale)
+        }, ...(contentOmitted ? { read: `yui task decision show ${decision.taskId} ${decision.id} --json` } : {}) };
+}
 export function taskDecisionCommand(args, store, options) {
     const [command, ...rest] = args;
     if (command === "record") {
@@ -136,7 +149,7 @@ export function taskDecisionCommand(args, store, options) {
         notifyMailbox(options.runtime, taskMailbox(result.task.id));
         if (result.task.status === "active")
             notifyMailbox(options.runtime, leaderMailbox(result.task.id));
-        return output(`Recorded decision ${result.decision.id} for ${result.task.id}\n`);
+        return output(`Recorded decision ${result.decision.id} for ${result.task.id}\n`, decisionReceipt(result.decision));
     }
     if (command === "list") {
         return taskRecordList(rest, store, "task-decision", options.environment);
@@ -144,7 +157,7 @@ export function taskDecisionCommand(args, store, options) {
     if (command === "show") {
         exactPositionals(rest, 2, "Task decision show usage: yui task decision show <task> <decision>.");
         const task = requireTask(store, rest[0]);
-        assertContextRecordReadable(store, task.id, "task-decision", rest[1], options.environment);
+        assertTaskReadable(store, task.id, options.environment);
         const decision = store.getDecision(task.id, rest[1]);
         if (decision === null)
             throw dataError(`Decision not found: ${rest[1]}.`);
@@ -190,7 +203,7 @@ export function taskDecisionCommand(args, store, options) {
         notifyMailbox(options.runtime, taskMailbox(result.task.id));
         if (result.task.status === "active")
             notifyMailbox(options.runtime, leaderMailbox(result.task.id));
-        return output(`Superseded decision ${result.decision.id} for ${result.task.id}\n`);
+        return output(`Superseded decision ${result.decision.id} for ${result.task.id}\n`, decisionReceipt(result.decision));
     }
     throw usageError(command === undefined
         ? "Task decision command is required."
@@ -228,7 +241,7 @@ export function taskMilestoneCommand(args, store, options) {
     if (command === "show") {
         exactPositionals(rest, 2, "Task milestone show usage: yui task milestone show <task> <milestone>.");
         const task = requireTask(store, rest[0]);
-        assertContextRecordReadable(store, task.id, "task-milestone", rest[1], options.environment);
+        assertTaskReadable(store, task.id, options.environment);
         const milestone = store.getMilestone(task.id, rest[1]);
         if (milestone === null)
             throw dataError(`Milestone not found: ${rest[1]}.`);
@@ -254,7 +267,7 @@ export function taskEventCommand(args, store, options = {}) {
     if (command === "show") {
         exactPositionals(rest, 2, "Task event show usage: yui task event show <task> <event>.");
         const task = requireTask(store, rest[0]);
-        assertContextRecordReadable(store, task.id, "task-event", rest[1], options.environment);
+        assertTaskReadable(store, task.id, options.environment);
         const event = store.queryContextRecords(task.id, {
             family: "task-event", ids: [rest[1]], limit: 1
         }).records[0]?.value;

package/dist/commands/taskIntegrationCommands.js

@@ -167,10 +167,10 @@ async function continueIntegration(args, store, home, now, options) {
             || integration.resolution?.action !== "manual-resolution")) {
         throw usageError(`Integration is not ready to continue: ${integration.id}/${integration.status}.`);
     }
-    return runIntegration(store, home, integration, now, options);
+    return runIntegration(store, home, integration, now, options, "continue");
 }
-async function runIntegration(store, home, integration, now, options) {
-    const result = await new GitIntegrationService(home, store, undefined, now, options.environment, undefined, options.jobPort).integrate(integration.taskId, integration.id);
+async function runIntegration(store, home, integration, now, options, intent) {
+    const result = await new GitIntegrationService(home, store, undefined, now, options.environment, undefined, options.jobPort).integrate(integration.taskId, integration.id, undefined, intent);
     const output = result.status === "committed"
         ? `Integrated ${integrationSourceLabel(result.attempt)} into ${result.attempt.targetRef} with CAS (${result.attempt.id})\n`
         : result.status === "conflicted"

package/dist/commands/taskRoleRuntimeStatus.js

@@ -49,6 +49,16 @@ export function withTaskRoleHostObservation(status, host) {
     };
 }
 export function inspectTaskRoleRuntimeStatuses(taskId, roles, store, panes, now = new Date()) {
+    if (roles.length === 0)
+        return [];
+    // One inspection shares the same Task history across Roles. This is local
+    // read reuse, not a cache of runtime health or provider observations.
+    const events = store.listEvents(taskId);
+    const history = {
+        events,
+        runs: operationalTaskRecords(store.listRuns(taskId), events, "run"),
+        workspaces: store.listManagedWorkspaces(taskId)
+    };
     const taskOpenInputRequestCount = store.listInputRequests(taskId)
         .filter((request) => request.status === "open").length;
     const panesByRole = new Map();
@@ -57,7 +67,7 @@ export function inspectTaskRoleRuntimeStatuses(taskId, roles, store, panes, now
         if (current === undefined || current.dead && !pane.dead)
             panesByRole.set(pane.roleName, pane);
     }
-    return roles.map((role) => inspectTaskRoleRuntimeStatus(taskId, role, store, panesByRole.get(role.name), role.name === "leader" ? taskOpenInputRequestCount : 0, now));
+    return roles.map((role) => inspectTaskRoleRuntimeStatus(taskId, role, store, panesByRole.get(role.name), role.name === "leader" ? taskOpenInputRequestCount : 0, now, history));
 }
 export function renderTaskRoleRuntimeStatus(status) {
     const activeRun = status.activeRun === null
@@ -185,12 +195,12 @@ export function taskRoleTmuxLabel(status) {
         ? "running"
         : `running (${status.tmux.currentCommand})`;
 }
-function inspectTaskRoleRuntimeStatus(taskId, role, store, pane, openInputRequestCount, now) {
+function inspectTaskRoleRuntimeStatus(taskId, role, store, pane, openInputRequestCount, now, history) {
     const activeRun = store.getActiveRun(taskId, role.name);
     // The last AgentRun outcome is a separate axis from the Session lifecycle. A
     // Session that stops after its AgentRun completed must not retroactively turn
     // that AgentRun into a failure; the status display keeps both visible.
-    const lastRun = operationalTaskRecords(store.listRuns(taskId), store.listEvents(taskId), "run")
+    const lastRun = history.runs
         .filter((candidate) => candidate.roleName === role.name)
         .sort((left, right) => Date.parse(right.updatedAt) - Date.parse(left.updatedAt))[0]
         ?? null;
@@ -221,12 +231,12 @@ function inspectTaskRoleRuntimeStatus(taskId, role, store, pane, openInputReques
     // distinct from the WorkItem Develop workspace.
     const actualWorkspaceRoot = effectiveLaunch?.workspace.root ?? role.workspace;
     const managedWorkspace = activeRun?.workspace
-        ?? store.listManagedWorkspaces(taskId).find(({ root }) => root === actualWorkspaceRoot)
+        ?? history.workspaces.find(({ root }) => root === actualWorkspaceRoot)
         ?? null;
     const workspace = managedWorkspace === null
         ? { managed: false, path: actualWorkspaceRoot }
         : { ...managedWorkspace, managed: true };
-    const events = store.listEvents(taskId);
+    const { events } = history;
     const sessionTokens = projectSessionTokenMetrics(events, resolveSessionTokenIdentity(nativeSession === null
         ? null
         : { taskId, roleName: role.name, ...nativeSession }));

package/dist/commands/taskUsageCommand.js

@@ -1,18 +1,14 @@
-import { assertContextRecordReadable } from "../context/taskContext.js";
+import { assertTaskReadable } from "../context/taskContext.js";
 import { readTaskUsage } from "../runtime/taskUsageQuery.js";
 import { formatUsageMetric } from "../runtime/taskUsageMetrics.js";
 import { exactPositionals, output, parseTail, requireTask } from "./taskCommandSupport.js";
 import { usageError } from "../errors/cliError.js";
-import { taskActor } from "../task/taskAuthority.js";
 export function taskUsageCommand(args, store, options) {
     const usage = "yui task usage <task> [--limit <0..50>] [--offset <n>]";
     const parsed = parseTail(args, new Set(["--limit", "--offset"]), usage);
     exactPositionals(parsed.positionals, 1, usage);
     const task = requireTask(store, parsed.positionals[0]);
-    // Task-lifetime aggregation spans every Role, beyond a Worker/Reviewer
-    // Assignment. Reading the Task record alone does not authorize these facts.
-    taskActor(options.environment, task.id);
-    assertContextRecordReadable(store, task.id, "task", task.id, options.environment);
+    assertTaskReadable(store, task.id, options.environment);
     const limit = Number(parsed.options.get("--limit") ?? 0), offset = Number(parsed.options.get("--offset") ?? 0);
     if (!Number.isSafeInteger(limit) || limit < 0 || limit > 50 || !Number.isSafeInteger(offset) || offset < 0) {
         throw usageError(usage);

package/dist/commands/textInput.js

@@ -1,6 +1,6 @@
 import { readFileSync } from "node:fs";
 import { usageError } from "../errors/cliError.js";
-export function readCommandText(inline, file, label, usage) {
+export function readCommandText(inline, file, label, usage, options = {}) {
     if ((inline === undefined) === (file === undefined)) {
         throw usageError(`Specify exactly one of ${label} or ${label}-file.`, usage);
     }
@@ -11,5 +11,5 @@ export function readCommandText(inline, file, label, usage) {
     if (normalized.length === 0 || normalized.includes("\0")) {
         throw usageError(`${label} is required.`, usage);
     }
-    return normalized;
+    return file !== undefined && options.preserveFileWhitespace ? value : normalized;
 }

package/dist/context/contextFamilies.js

@@ -0,0 +1,10 @@
+/** Public current-Context family names, shared by reads and CLI discovery.
+ * Listing a family grants no permission to read its records.
+ */
+export const CONTEXT_FAMILIES = Object.freeze([
+    "task", "task-brief", "remote-delivery", "role", "role-profile",
+    "project-policy", "project-knowledge", "input-request", "work-item",
+    "accepted-work-item", "candidate", "environment-preparation", "managed-workspace",
+    "change-set", "task-message", "run", "source-run", "review-round", "mailbox",
+    "task-decision", "task-milestone", "job", "publication", "task-event"
+]);

package/dist/context/currentSkills.js

@@ -42,7 +42,9 @@ export function checkCurrentSkills(home, ids) {
     });
 }
 export const SKILL_CHECK_COMMAND = "yui session skills --json";
-export const SKILL_REUSE_RULE = "At the start of every turn, check current Skill versions and availability. "
-    + "Read full SKILL.md and necessary references on first entry, version change, recovery, "
-    + "or missing/compacted/uncertain context; reuse only unchanged full instructions available now. "
-    + "A version check is not a loading receipt or authority.";
+export const SKILL_REUSE_RULE = "The managed Host checks current Skill versions/availability before each input; "
+    + "do not repeat an explicit Host check. Without that notice, check through the Manifest's command. "
+    + "Reuse unchanged full instructions in context; messages alone require no reload. "
+    + "Read affected entries/references fully on change or localized loss. On first entry, recovery or lost context, "
+    + "rebuild the current working set from applicable Skill entry points and action-relevant references, not all past procedures. "
+    + "Metadata proves neither loading, memory nor authority.";

package/dist/context/runContextPack.js

@@ -371,9 +371,11 @@ export function runContextEntry(pack) {
     const { skillPackages: _packages, pointers: _pointers, deltaRefs, liveTaskState, input, ...identity } = pack;
     const { directive, ...inputIdentity } = input;
     const { items, ...pointerPage } = runContextPointerPage(pack, { limit: 16 });
+    const directiveSummary = directive === undefined ? undefined : summaryText(directive);
     return {
         ...identity, input: { ...inputIdentity, ...(directive === undefined ? {} : {
-                directiveSummary: summaryText(directive), directiveOmitted: true
+                ...(directiveSummary === directive ? { directive, directiveOmitted: false }
+                    : { directiveSummary, directiveOmitted: true })
             }) }, pointers: items, pointerPage,
         deltaRefs: deltaRefs.slice(0, 16), deltaRefsTotal: deltaRefs.length,
         inventory: { ...pack.inventory, complete: pointerPage.complete },
@@ -386,9 +388,16 @@ export function runContextEntry(pack) {
         },
         reads: {
             inbox: "yui inbox list --view current --json",
-            refs: `yui task run context ${pack.identity.taskId}/${pack.identity.runId} --view refs`,
+            ...(items.length > 0 ? {
+                expand: `yui task run context expand ${pack.identity.taskId}/${pack.identity.runId} --context-ref <store/refId> [--context-ref <store/refId> ...] --mode full --json`
+            } : {}),
+            ...(!pointerPage.complete ? {
+                refs: `yui task run context ${pack.identity.taskId}/${pack.identity.runId} --view refs`
+            } : {}),
             full: `yui task run context ${pack.identity.taskId}/${pack.identity.runId} --view full`,
-            input: `yui task run context ${pack.identity.taskId}/${pack.identity.runId} --view input`,
+            ...(directiveSummary !== directive ? {
+                input: `yui task run context ${pack.identity.taskId}/${pack.identity.runId} --view input`
+            } : {}),
             live: `yui task context ${pack.identity.taskId}`
         }
     };
@@ -413,7 +422,7 @@ function readLiveTaskState(store, taskId) {
     }));
     return Object.freeze({
         providerRetries: Object.freeze(store.listRoleSessionSets(taskId).flatMap(set => set.providerBinding?.retry === undefined
-            ? [] : [{ roleName: set.owner.roleName, retry: providerRetrySummary(set.providerBinding) }])),
+            ? [] : [{ roleName: set.owner.roleName, retry: providerRetrySummary(set.providerBinding, `yui task role session retry ${taskId} ${set.owner.roleName} show --json`) }])),
         activeRuns: Object.freeze(activeRuns),
         activeTaskReviews: Object.freeze(activeTaskReviews)
     });
@@ -422,6 +431,34 @@ export function expandRunContextRef(store, taskId, runId, refId, refStore) {
     requireIdentity(refStore, "Context ref store");
     const run = requireExactRun(store, taskId, runId);
     const snapshot = readRunContextSnapshot(store, run);
+    return expandSnapshotRef(snapshot, refId, refStore);
+}
+/** Explicit originals from one already-authorized frozen Run, not live Task
+ * discovery. Read the snapshot once and reject the entire selection on drift. */
+export function expandRunContextRefs(store, taskId, runId, selectors) {
+    if (selectors.length < 1 || selectors.length > 8)
+        throw new Error("Run Context batch requires 1..8 exact references.");
+    const seen = new Set();
+    for (const ref of selectors) {
+        requireIdentity(ref.store, "Context ref store");
+        requireIdentity(ref.refId, "Context ref id");
+        if (ref.digest !== undefined && !/^[a-f0-9]{64}$/.test(ref.digest))
+            throw new Error("An explicit Run Context digest must be exact.");
+        const key = JSON.stringify([ref.store, ref.refId]);
+        if (seen.has(key))
+            throw new Error("Duplicate Run Context batch reference.");
+        seen.add(key);
+    }
+    const snapshot = readRunContextSnapshot(store, requireExactRun(store, taskId, runId));
+    const items = selectors.map(ref => {
+        const expanded = expandSnapshotRef(snapshot, ref.refId, ref.store);
+        if (ref.digest !== undefined && expanded.ref.digest !== ref.digest)
+            throw new Error(`Run Context reference digest does not match its frozen Snapshot: ${ref.store}/${ref.refId}.`);
+        return expanded;
+    });
+    return { taskId, runId, items };
+}
+function expandSnapshotRef(snapshot, refId, refStore) {
     const authorized = snapshot.refs.filter((ref) => (ref.refId === refId && ref.store === refStore));
     const selector = `${refStore}/${refId}`;
     if (authorized.length !== 1) {
@@ -770,7 +807,9 @@ function materialize(layer, store, refId, value) {
             summary: (store === "project-knowledge"
                 ? [title, `version: ${record.version}`, ...(record.scope === undefined ? [] : [`scope: ${record.scope}`]),
                     ...(record.expiresWhen === undefined ? [] : [`expiresWhen: ${record.expiresWhen}`])].join("; ")
-                : title).slice(0, 400)
+                : store === "task-message" && typeof record.body === "string"
+                    ? summaryText(`Excerpt: ${record.body}`, 160)
+                    : title).slice(0, 400)
         }),
         value
     });

package/dist/context/runInputContract.js

@@ -79,7 +79,7 @@ export function serializeRunInputEnvelope(value) {
         .join(",");
     const snapshot = normalized.contextSnapshotRef;
     const lines = [
-        "Yui AgentRun input. Check current Skills: yui session skills --json. Follow the Session Manifest profile and current Skills.",
+        "Yui AgentRun input. Follow the Session Manifest profile and current Skills; use the Host check when supplied.",
         `${normalized.subject.taskId === undefined ? "" : `task=${normalized.subject.taskId} `}run=${normalized.runId} role=${normalized.roleName}`,
         `source=${normalized.source.type}/${normalized.source.channel} purpose=${normalized.purpose} subject=${subject || "global"} snapshot=${snapshot === undefined ? "none" : `${snapshot.id}@${snapshot.digest}`}`,
         normalized.deltaRefIds.length === 0

package/dist/context/sessionBootstrapManifest.js

@@ -18,13 +18,15 @@ export function withSessionContextPointer(text, environment) {
         text
     ].join("\n");
 }
-/** No remembered/sent flag can prove instructions survived context compaction. */
+/** Host metadata checks do not prove instructions survived context compaction.
+ * Unmediated/native clients retain the explicit diagnostic fallback. */
 export function sessionContextInstructions(manifestPath, digest) {
     return `Yui Session Manifest: ${manifestPath}${digest === undefined ? "" : ` (digest ${digest})`}. `
-        + `Before work on every turn run the Manifest's contextProtocol.skillCheckCommand `
-        + `(older Manifests: ${SKILL_CHECK_COMMAND}; Global loadCommand also checks current Skills). `
-        + "Use its current stable Skill paths instead of historical frozen-package paths; preserve the Manifest's Role profile. "
-        + SKILL_REUSE_RULE;
+        + "For inputs carrying the Yui Host Skill-check notice, engineering has checked current versions; do not repeat that check. "
+        + `Otherwise run its contextProtocol.skillCheckCommand (fallback: ${SKILL_CHECK_COMMAND}). `
+        + "On first entry or lost instructions, read the current applicable Skill entry points, then only references needed for the current action. "
+        + "On change reload affected instructions. Compaction does not require restoring every previously used procedure. "
+        + "Preserve the Manifest Role profile; metadata never proves loading or memory.";
 }
 /** The caller must already pass the ordinary managed Session/CLI/Home checks.
  * Old manifests remain immutable audit records, while this read resolves their

package/dist/context/sessionSkillNotice.js

@@ -0,0 +1,53 @@
+import { checkSessionSkills } from "./sessionBootstrapManifest.js";
+/** Host-local last accepted metadata, never a model loading/memory receipt.
+ * A new Host/attachment starts cold. No durable schema or input replay is added. */
+export function createSessionSkillNotice(home) {
+    let previous;
+    let generation = 0;
+    const invalidate = () => { previous = undefined; generation += 1; };
+    return {
+        invalidate,
+        prepare(text, environment, sessionKey, options = {}) {
+            const manifest = environment.YUI_SESSION_MANIFEST;
+            if (manifest === undefined)
+                return { text, commit() { } };
+            if (options.recovery)
+                invalidate();
+            let current;
+            try {
+                current = checkSessionSkills(home, manifest);
+            }
+            catch (error) {
+                invalidate();
+                throw error; // Do not submit business input with an invalid current installation.
+            }
+            const key = JSON.stringify([sessionKey, manifest, current.roleProfileRef]);
+            const skills = new Map(current.skills.map(skill => [skill.id, JSON.stringify({
+                    id: skill.id, path: skill.path, version: skill.version
+                })]));
+            const cold = previous?.key !== key;
+            const changed = [...skills].filter(([id, value]) => cold || previous.skills.get(id) !== value)
+                .map(([, value]) => value);
+            const removed = !cold && [...previous.skills.keys()].some(id => !skills.has(id));
+            // Every input is checked, but only a lifecycle/metadata event needs an
+            // instruction-loading notice. This marker distinguishes Host-mediated
+            // input from an unmediated client without restating the operating manual.
+            const lines = ["Yui Host checked current Skills; no Agent check needed."];
+            if (cold || changed.length > 0 || removed) {
+                lines.push(`Yui Session Manifest: ${manifest}`, cold
+                    ? `First input or recovered attachment: read the exact Role profile at ${current.roleProfileRef.path} and the full current listed Skill entry points. Follow references only for the action you are taking, not to restore every previously used procedure. A Task role-profile projection is not this profile.`
+                    : "Skill metadata changed: load affected entries and applicable references; retain other complete instructions.", `Current Skill pointers: [${(removed ? [...skills.values()] : changed).join(",")}]`, "Metadata is not a loading receipt. Read each required file through EOF; if output is truncated, finish the missing ranges. Recover missing instructions for the current task, not the whole manual.");
+            }
+            const preparedGeneration = generation;
+            return {
+                text: `${lines.join("\n")}\n\n${text}`,
+                commit() {
+                    if (generation !== preparedGeneration)
+                        return;
+                    previous = { key, skills };
+                    generation += 1;
+                }
+            };
+        }
+    };
+}

package/dist/context/taskCatalog.js

@@ -50,26 +50,17 @@ export function parseTaskCatalogOptions(args) {
         ...(values.has("--cursor") ? { cursor: values.get("--cursor") } : {})
     };
 }
-/** Task-local Leaders discover only their Task. Assignment Roles use their
- * existing Context pack: whole-Task counts would leak unrelated assignments. */
-export function taskCatalogScope(store, environment) {
-    const caller = resolveContextReader(store, environment);
-    if (caller !== undefined && caller.roleName !== "leader") {
-        throw usageError("Task discovery is unavailable to an Assignment-scoped Role; use its authorized Run Context.");
-    }
-    return caller?.taskId;
-}
 export function readTaskCatalog(store, options, environment = {}) {
     return store.transaction(reader => {
-        const taskId = taskCatalogScope(reader, environment);
+        resolveContextReader(reader, environment);
         const { cursor: rawCursor, ...filters } = options;
         if (!Number.isSafeInteger(filters.limit) || filters.limit < 1 || filters.limit > MAX_LIMIT) {
             throw usageError("Task catalog limit must be between 1 and 100.");
         }
-        const scope = contextContentDigest({ taskId: taskId ?? null, ...filters });
+        const scope = contextContentDigest({ taskId: null, ...filters });
         const cursor = rawCursor === undefined ? undefined : decodeCursor(rawCursor, scope);
         const facts = reader.queryTaskCatalog({
-            ...filters, ...(taskId === undefined ? {} : { taskId }),
+            ...filters,
             ...(cursor === undefined ? {} : { after: cursor.after, through: cursor.through }),
             limit: options.limit + 1
         });
@@ -106,7 +97,7 @@ export function readTaskCatalog(store, options, environment = {}) {
         }));
         const response = {
             view: "compact",
-            scope: { taskId: taskId ?? null, archived: options.all ? "included" : "excluded",
+            scope: { taskId: null, archived: options.all ? "included" : "excluded",
                 attention: "authorized-catalog-before-filters", executionSignals: "raw-inspection-candidates-not-execution-status" },
             filters, total: facts.total, counts: facts.counts, attention,
             tasks: [],