toolroll 0.9.44 → 0.9.45

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 0.9.45 — 2026-10-07
+
+- **Your projects, your lists.** People with access to some projects can now
+  run `status`, `task list` and `ready` remotely, and their agents' list
+  tools, and see and count only those projects. A task waiting on one in
+  another project says "waits for a task in another project", with no id,
+  and queue position counts only your projects. Owners see exactly what they
+  did before.
+- Still unavailable remotely for limited access: `brief`, `spend` and
+  choosing a task's `--id`.
+
 ## 0.9.44 — 2026-10-07
 
 - **Work from your own laptop.** `toolroll connect https://… --token so_…`

package/dist/cli-http.d.ts

@@ -1,5 +1,6 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import type { Store } from './store.js';
+import type { Principal } from './operate.js';
 import { type RemoteCommandLookup } from './remote-command.js';
 /**
  * `POST /api/cli` (remote CLI, Phase 1): a teammate's laptop sends the argv it would have run locally, and the central
@@ -10,22 +11,10 @@ import { type RemoteCommandLookup } from './remote-command.js';
  * Only `Authorization: Bearer so_…` is accepted — never a password, cookie or the owner's saved login — and a request
  * carrying a browser Origin is refused, so a page can never drive it.
  */
-/** Who a remote command runs as. The shared seam with operate.ts (remote-principal). */
-export type Principal = {
-    kind: 'person';
-    account: string;
-    generation: number;
-    scope: 'read' | 'act';
-    tokenId: string;
-    projects: string[] | null;
-};
-export type RunOperateAs = (argv: string[], opts: {
-    principal: Principal;
-    store: Store;
-    write: (s: string) => void;
-    files?: Record<string, string>;
-    source?: 'api' | 'mcp';
-}) => Promise<number>;
+/** Who a remote command runs as, and the runner: operate.ts's own types, so a change there breaks this build instead of
+ * drifting. Type-only: the value is loaded lazily through `run` (operate.ts imports the server that imports this). */
+export type { Principal } from './operate.js';
+export type RunOperateAs = typeof import('./operate.js').runOperateAs;
 export type CliRequest = {
     argv: string[];
     files: Record<string, string>;

package/dist/desktop-update.d.ts

@@ -94,13 +94,13 @@ export declare function prepareDesktopUpdate(stateDir: string, installed: string
 export declare function sqliteLock(file: string, busyTimeoutMs?: number): DatabaseSync | null;
 export declare const installationLock: (j: UpdateJournal) => DatabaseSync | null;
 export declare function desktopUpdateStatus(stateDir: string): {
-    error?: never;
     active: boolean;
     phase: string;
     detail: string;
     running: boolean;
     canResume: boolean;
     canCancel: boolean;
+    error?: never;
     automaticRecovery?: never;
     recoveryAttempts?: never;
     recoveryRepairs?: never;

package/dist/dispatch.d.ts

@@ -94,8 +94,8 @@ export declare function scopeApprovedForDispatch(store: Store, taskRef: number,
 export declare function dispatchRoleFor(store: Store, taskRef: number, now: Date): "builder" | "planner" | "scout";
 /** The first requirement this task fails, in words, or null. */
 export declare function missingCapability(store: Store, taskRef: number, dispatchRepo: string | null, now: Date): string | null;
-/** The read-side lifecycle answer. It changes nothing and grants nothing. */
-export declare function diagnoseTaskDispatch(store: Store, taskId: string, now: Date): DispatchDiagnosis | null;
+/** The read-side lifecycle answer. Project access limits dependency detail, never the readiness gate. */
+export declare function diagnoseTaskDispatch(store: Store, taskId: string, now: Date, readableRepos?: readonly string[] | null): DispatchDiagnosis | null;
 export declare function diagnosisIsDispatchable(diagnosis: DispatchDiagnosis | null): boolean;
 /** Attach the same lifecycle answer to the bounded fleet snapshot used by
  * both direct chat and the long-running mate. */

package/dist/dispatch.js

@@ -163,8 +163,8 @@ function approvedProfile(scope) {
         return null;
     return scope.approvedProfile ?? scope.profile ?? null;
 }
-/** The read-side lifecycle answer. It changes nothing and grants nothing. */
-export function diagnoseTaskDispatch(store, taskId, now) {
+/** The read-side lifecycle answer. Project access limits dependency detail, never the readiness gate. */
+export function diagnoseTaskDispatch(store, taskId, now, readableRepos = null) {
     const task = store.getTask(taskId);
     const ref = store.lookupRef(taskId);
     if (task === null || ref === null)
@@ -251,9 +251,13 @@ export function diagnoseTaskDispatch(store, taskId, now) {
     }
     if (local?.code === "dependency") {
         const terminal = local.blockerState === "failed" || local.blockerState === "cancelled";
+        const blockerRepo = readableRepos === null ? null : store.lookupRef(local.blockerId)?.repo;
+        const hidden = readableRepos !== null && (blockerRepo == null || !readableRepos.includes(blockerRepo));
+        const blocker = hidden ? "A task in another project" : local.blockerId;
+        const blockerTaskId = hidden ? null : local.blockerId;
         return terminal
-            ? answer("terminal-dependency", "waiting", "A required task did not finish", `${local.blockerId} ${local.blockerState === "cancelled" ? "was cancelled" : "failed"} before it finished.`, { action: "repair-dependency", blockerTaskId: local.blockerId })
-            : answer("waiting-dependency", "waiting", "Waiting for another task", `${local.blockerId} must finish before this task can start.`, { blockerTaskId: local.blockerId });
+            ? answer("terminal-dependency", "waiting", "A required task did not finish", `${blocker} ${local.blockerState === "cancelled" ? "was cancelled" : "failed"} before it finished.`, { action: "repair-dependency", blockerTaskId })
+            : answer("waiting-dependency", "waiting", "Waiting for another task", `${blocker} must finish before this task can start.`, { blockerTaskId });
     }
     const role = dispatchRoleFor(store, ref.id, now);
     const scope = store.getScope(taskId);

package/dist/lead-status.d.ts

@@ -101,7 +101,11 @@ export declare function repairStaleStatuses(store: Store, now: Date): {
     exitsRecorded: number;
     readyForReview: number;
 };
-/** `viewer`: the person asking (the lead asks as its person); null when nobody is known, which shows no lead. */
-export declare function installationStatus(store: Store, now: Date, viewer?: string | null): InstallationStatus;
-export declare function renderInstallationStatus(status: InstallationStatus): string[];
+/** `viewer`: the person asking (the lead asks as its person); null when nobody is known, which shows no lead.
+ * `repos`: the only projects to report (a remote person limited to some projects); null is the whole installation.
+ * A limited report counts only those projects' tasks and leaves out what belongs to the installation as a whole:
+ * the release check, plan windows and the lead line are empty, never another project's. */
+export declare function installationStatus(store: Store, now: Date, viewer?: string | null, repos?: readonly string[] | null): InstallationStatus;
+/** `limited`: a report over some projects (installationStatus's `repos`), which has no release check or plan windows to state. */
+export declare function renderInstallationStatus(status: InstallationStatus, limited?: boolean): string[];
 export declare function renderTaskWait(snapshot: TaskWaitSnapshot, outcome?: string): string;

package/dist/lead-status.js

@@ -181,15 +181,20 @@ export function repairStaleStatuses(store, now) {
     const exitsRecorded = store.recordFinishedRunExits(now);
     return { exitsRecorded, readyForReview: workReadyForReview(store, now, { principal: "operator", repos: null, includeUnplaced: true }, 0).count };
 }
-/** `viewer`: the person asking (the lead asks as its person); null when nobody is known, which shows no lead. */
-export function installationStatus(store, now, viewer = currentActor()?.account ?? null) {
-    const runningRows = store.handle.prepare(`SELECT run.id, run.role, run.phase, ref.id AS task_ref, ref.external_id AS task
+/** `viewer`: the person asking (the lead asks as its person); null when nobody is known, which shows no lead.
+ * `repos`: the only projects to report (a remote person limited to some projects); null is the whole installation.
+ * A limited report counts only those projects' tasks and leaves out what belongs to the installation as a whole:
+ * the release check, plan windows and the lead line are empty, never another project's. */
+export function installationStatus(store, now, viewer = currentActor()?.account ?? null, repos = null) {
+    const admitted = (row) => repos === null || typeof row["repo"] === "string" && repos.includes(row["repo"]);
+    const access = { principal: "operator", repos, includeUnplaced: repos === null };
+    const runningRows = store.handle.prepare(`SELECT run.id, run.role, run.phase, ref.id AS task_ref, ref.external_id AS task, ref.repo
     FROM run INDEXED BY work_unfinished
     JOIN task_ref AS ref ON ref.id = run.task_ref
     JOIN claim ON claim.lease_id = run.lease_id
     WHERE run.outcome IS NULL AND claim.released_at IS NULL AND claim.expires_at > ?
       AND claim.lease_generation = (SELECT MAX(newest.lease_generation) FROM claim AS newest INDEXED BY claim_by_task WHERE newest.task_ref = run.task_ref)
-    ORDER BY run.id`).all(now.toISOString());
+    ORDER BY run.id`).all(now.toISOString()).filter(admitted);
     const phases = new Map();
     const runningTasks = runningRows.map(row => {
         const phase = phaseWords(phaseOf(row));
@@ -197,7 +202,7 @@ export function installationStatus(store, now, viewer = currentActor()?.account
         return { task: String(row["task"]), run: Number(row["id"]), phase };
     });
     const runningRefs = new Set(runningRows.map(row => Number(row["task_ref"])));
-    const queuedRows = store.handle.prepare(`SELECT task.id, ref.id AS task_ref, ref.plan, ref.strikes, scope.digest AS scope_digest,
+    const queuedRows = store.handle.prepare(`SELECT task.id, ref.id AS task_ref, ref.repo, ref.plan, ref.strikes, scope.digest AS scope_digest,
       scope.profile_state,
       (scope.approved_at IS NOT NULL AND scope.approved_by IS NOT NULL AND scope.approved_digest = scope.digest) AS approved,
       EXISTS (SELECT 1 FROM task_edge WHERE task_edge.blocked = task.id
@@ -208,7 +213,7 @@ export function installationStatus(store, now, viewer = currentActor()?.account
     JOIN task_ref AS ref INDEXED BY sqlite_autoindex_task_ref_1 ON ref.backend = ? AND ref.external_id = task.id
     LEFT JOIN task_scope AS scope ON scope.task_id = task.id
     WHERE task.state = 'queued'`).all(now.toISOString(), BUILT_IN)
-        .filter(row => !runningRefs.has(Number(row["task_ref"])));
+        .filter(row => !runningRefs.has(Number(row["task_ref"])) && admitted(row));
     const reasons = new Map();
     const queuedTasks = [];
     const pauses = openAuthPauses(store);
@@ -227,11 +232,11 @@ export function installationStatus(store, now, viewer = currentActor()?.account
     }
     // One per family, from the same projection as the Tasks list: a completed
     // family (root or any revision) and a superseded version never count.
-    const ready = workReadyForReview(store, now, { principal: "operator", repos: null, includeUnplaced: true }, 5);
+    const ready = workReadyForReview(store, now, access, 5);
     const checkRow = (run) => store.handle.prepare(`SELECT ${CHECK_COLUMNS} FROM run_check AS rc WHERE rc.run = ?`).get(run);
     // Run ids grow with time, so the newest finished release check is the
     // first finished row down the partial index.
-    const release = store.handle.prepare(`SELECT run.id, run.finished_at, ${CHECK_COLUMNS}, ref.external_id AS task
+    const release = repos !== null ? undefined : store.handle.prepare(`SELECT run.id, run.finished_at, ${CHECK_COLUMNS}, ref.external_id AS task
     FROM run_check AS rc INDEXED BY run_check_release
     JOIN run ON run.id = rc.run
     JOIN task_ref AS ref ON ref.id = run.task_ref
@@ -247,7 +252,7 @@ export function installationStatus(store, now, viewer = currentActor()?.account
         },
         waitingForReview: { count: ready.count, results: ready.results.map(one => ({ task: one.taskId, run: one.run, check: checkOf(one.run === null ? undefined : checkRow(one.run)) })) },
         releaseCheck: release === undefined ? null : { task: String(release["task"]), run: Number(release["id"]), finishedAt: release["finished_at"] == null ? null : String(release["finished_at"]), check: checkOf(release) },
-        planWindows: store.handle.prepare(`SELECT provider, window, used_percent, window_minutes, resets_at, reached, plan, observed_at
+        planWindows: repos !== null ? [] : store.handle.prepare(`SELECT provider, window, used_percent, window_minutes, resets_at, reached, plan, observed_at
       FROM provider_limit INDEXED BY sqlite_autoindex_provider_limit_1 ORDER BY provider, window`).all().map(row => ({
             provider: String(row["provider"]),
             plan: row["plan"] == null ? null : String(row["plan"]),
@@ -259,16 +264,17 @@ export function installationStatus(store, now, viewer = currentActor()?.account
             observedAt: String(row["observed_at"]),
         })),
         signIn: pauses.map(one => ({ provider: one.provider, reason: signInReason(one), command: signInCommand(one), since: one.openedAt })),
-        tasks: workIndexPage(store, now, { principal: "operator", repos: null, includeUnplaced: true, viewer }, { limit: 8 }).items
+        tasks: workIndexPage(store, now, { ...access, viewer }, { limit: 8 }).items
             .map(one => ({ task: one.rootId, title: one.title, headline: one.status.label, sentence: one.status.detail })),
-        lead: (() => {
+        lead: repos !== null ? null : (() => {
             // Only the asker's own lead: another person's lead is never "Your lead".
             const activity = leadActivity(store, viewer);
             return activity === null ? null : { owner: activity.owner, doing: activity.doing, at: activity.at, task: activity.taskId, line: leadActivityLine(activity, now) };
         })(),
     };
 }
-export function renderInstallationStatus(status) {
+/** `limited`: a report over some projects (installationStatus's `repos`), which has no release check or plan windows to state. */
+export function renderInstallationStatus(status, limited = false) {
     const lines = [];
     // A paused provider comes first: it is the one thing a person must do.
     for (const one of status.signIn)
@@ -284,6 +290,9 @@ export function renderInstallationStatus(status) {
     lines.push(status.running.count === 0 ? "Building: none" : `Building: ${status.running.count} — ${status.running.tasks.map(one => `${one.task} (#${one.run}, ${one.phase})`).join(", ")}${status.running.count > status.running.tasks.length ? ", …" : ""}`);
     lines.push(status.queued.count === 0 ? "Queued: none" : `Queued: ${status.queued.count} — ${status.queued.tasks.map(one => `${one.task} (${one.reason})`).join(", ")}${status.queued.count > status.queued.tasks.length ? ", …" : ""}`);
     lines.push(status.waitingForReview.count === 0 ? "Ready for review: none" : `Ready for review: ${status.waitingForReview.count} — ${status.waitingForReview.results.map(one => one.run === null ? one.task : `${one.task} (#${one.run})`).join(", ")}${status.waitingForReview.count > status.waitingForReview.results.length ? ", …" : ""}`);
+    // Neither the release check nor plan windows belong to a person's projects: a limited report leaves both out.
+    if (limited)
+        return lines;
     if (status.releaseCheck === null) {
         lines.push("Release check: none recorded");
     }

package/dist/operate-remote.d.ts

@@ -33,6 +33,8 @@ export declare const REMOTE_MESSAGES: {
 /**
  * How a "yes" command finds the project it touches, before it runs. Any --repo given is checked too.
  *  installation — reads or acts across every project: only for someone with access to all of them.
+ *  listing — lists across projects: someone with access to all of them sees everything, as locally; anyone else
+ *    sees only their own projects (the run's `lens`), with every count taken over those projects alone.
  *  repo — needs --repo, naming a project the server knows and the person may use.
  *  references — the audited arguments resolve every resource to its stored project before dispatch.
  *  self — the command already narrows to the person's own projects (their access is passed in).
@@ -40,6 +42,8 @@ export declare const REMOTE_MESSAGES: {
  */
 export type RemoteScope = {
     kind: "installation";
+} | {
+    kind: "listing";
 } | {
     kind: "repo";
 } | {
@@ -51,6 +55,14 @@ export type RemoteScope = {
 };
 /** Every "yes" row's scope. The remote test holds this to the guide's "yes" rows exactly. */
 export declare const REMOTE_SCOPES: ReadonlyMap<string, RemoteScope>;
+/**
+ * Why each "installation" row still needs access to every project rather than listing a person's own. The remote
+ * test holds this to the table's "installation" rows exactly, so a newly allowed cross-project command has to be
+ * scoped as a listing or stated here; it cannot skip project scoping by omission.
+ */
+export declare const REMOTE_ALL_PROJECTS_ONLY: ReadonlyMap<string, "installation-wide" | "not yet scoped">;
+/** The projects a listing or task reference may disclose: null for someone with access to all of them. */
+export declare function remoteLensOf(store: Store, scope: RemoteScope, allows: (repo: string | null) => boolean): readonly string[] | null;
 /** Flags a remote caller never passes: who they are comes from the token, and the server reads and writes no paths for them. */
 export declare const REMOTE_REFUSED_FLAGS: ReadonlySet<string>;
 /**

package/dist/operate-remote.js

@@ -31,15 +31,15 @@ export const REMOTE_MESSAGES = {
     files: "Send that file with the request; the server reads no paths of its own for you.",
 };
 const installation = { kind: "installation" }, repo = { kind: "repo" }, self = { kind: "self" }, global = { kind: "global" };
-const references = { kind: "references" };
+const references = { kind: "references" }, listing = { kind: "listing" };
 /** Every "yes" row's scope. The remote test holds this to the guide's "yes" rows exactly. */
 export const REMOTE_SCOPES = new Map([
-    ["status", installation], ["integrations", installation], ["ready", installation], ["grants", installation], ["sync", installation],
+    ["status", listing], ["integrations", installation], ["ready", listing], ["grants", installation], ["sync", installation],
     ["gaps", repo], ["task add", repo],
     ...["ask", "checks", "add-tests", "show", "wait", "complete", "revise", "state", "block", "unblock", "next", "steer", "assign", "scope", "plan", "hold",
         "unhold", "require", "requeue", "review", "repair", "route", "reopen", "stop", "resume"].map(action => [`task ${action}`, references]),
     ["check-progress", references],
-    ["task list", installation],
+    ["task list", listing],
     ["runner list", installation], ["coordinator list", installation], ["outbox list", installation], ["incident list", installation], ["incident resolve", installation],
     ["cap list", repo], ["cap add", repo],
     ...["list", "show", "add", "refresh", "pause", "resume", "run-now"].map(action => [`routine ${action}`, installation]),
@@ -53,6 +53,25 @@ export const REMOTE_SCOPES = new Map([
         .map(action => [`flows ${action}`, self]),
     ["models status", global], ["models list", global],
 ]);
+/**
+ * Why each "installation" row still needs access to every project rather than listing a person's own. The remote
+ * test holds this to the table's "installation" rows exactly, so a newly allowed cross-project command has to be
+ * scoped as a listing or stated here; it cannot skip project scoping by omission.
+ */
+export const REMOTE_ALL_PROJECTS_ONLY = new Map([
+    // Settings, connections and acts that belong to the installation as a whole, not to any one project.
+    ...["integrations", "grants", "sync", "incident resolve", "routine add", "routine refresh", "routine pause", "routine resume", "routine run-now",
+        "config show", "intake run", "contest exclude", "webhook status", "webhook test"].map(row => [row, "installation-wide"]),
+    // Cross-project lists and reads a limited person is still refused; scoping them is later work.
+    ...["runner list", "coordinator list", "outbox list", "incident list", "routine list", "routine show", "intake show", "intake preview",
+        "intake pr-comments", "template list", "template show", "contest show", "review show"].map(row => [row, "not yet scoped"]),
+]);
+/** The projects a listing or task reference may disclose: null for someone with access to all of them. */
+export function remoteLensOf(store, scope, allows) {
+    if ((scope.kind !== "listing" && scope.kind !== "references") || allows(null))
+        return null;
+    return Object.freeze(store.knownRepos().filter(repo => allows(repo)));
+}
 /** Flags a remote caller never passes: who they are comes from the token, and the server reads and writes no paths for them. */
 export const REMOTE_REFUSED_FLAGS = new Set([
     "db", "as", "token", "token-file", "token-env", "password", "key-file", "credentials", "containment", "out", "project-root", "bin", "port", "host",
@@ -111,6 +130,7 @@ export function remoteProjectOf(store, run, scope, positional, repos, invocation
     switch (scope.kind) {
         case "global":
         case "self":
+        case "listing":
             return checked;
         case "installation":
             return run.allows(null) ? { ok: true, repo: named, taskId: null } : { ok: false, reason: "all-projects", message: REMOTE_MESSAGES.installation };

package/dist/operate.js

@@ -154,7 +154,7 @@ import { ask as promptAsk, askHidden as promptHidden, confirm as promptConfirm,
 import { runMateCli, answerContextLines } from "./mate-cli.js";
 import { confirmCoordinatorProposal, dismissCoordinatorProposal } from "./mate-doors.js";
 import { verifyApproverByPassword as approverByPassword } from "./principal.js";
-import { activeRemote, REMOTE_MESSAGES, REMOTE_REFUSED_FLAGS, REMOTE_SCOPES, RemoteRefusal, remoteAllows, remoteProjectOf, remoteRowOf, remoteSecret, reproveRemote, withRemote } from "./operate-remote.js";
+import { activeRemote, REMOTE_MESSAGES, REMOTE_REFUSED_FLAGS, REMOTE_SCOPES, RemoteRefusal, remoteAllows, remoteLensOf, remoteProjectOf, remoteRowOf, remoteSecret, reproveRemote, withRemote } from "./operate-remote.js";
 import { projectAuthority } from "./project-access.js";
 import { authorizedProject, canonicalProject, projectName, resolveCeiling } from "./project.js";
 import { tally, spendLine } from "./summary.js";
@@ -975,17 +975,20 @@ export async function runOperateAs(argv, opts) {
     const file = store.databaseFile() ?? options.databaseFile;
     if (file === undefined)
         return refuse("failed", "The server's database has no file.", project.repo, project.taskId);
-    const run = Object.freeze({ account: principal.account, scope: proved.scope, tokenName: proved.tokenName, source, secret: remoteSecret(), allows, files: Object.freeze({ ...(opts.files ?? {}) }) });
+    // The task a `task add` filed is only known once it runs; the final history line names it.
+    let filed = null;
+    const run = Object.freeze({ account: principal.account, scope: proved.scope, tokenName: proved.tokenName, source, secret: remoteSecret(), allows,
+        lens: remoteLensOf(store, scope, allows), noteTask: (taskId) => { filed = taskId; }, files: Object.freeze({ ...(opts.files ?? {}) }) });
     record("requested", project.repo, project.taskId, null);
     let code;
     try {
         code = await withRemote(run, () => dispatchOn(root, parsed.positional, parsed.flags, parsed.repoList, { store, write, json, file, now }, options, go => withActor({ account: principal.account, lead: false }, () => projectAuthority.run({ actor: principal.account, repo: project.repo }, go))));
     }
     catch (error) {
-        record("failed", project.repo, project.taskId, null);
+        record("failed", project.repo, filed ?? project.taskId, null);
         throw error;
     }
-    record(code === EXIT.ok ? "done" : code === EXIT.refused ? "refused" : code === EXIT.usage ? "usage" : "failed", project.repo, project.taskId, null);
+    record(code === EXIT.ok ? "done" : code === EXIT.refused ? "refused" : code === EXIT.usage ? "usage" : "failed", project.repo, filed ?? project.taskId, null);
     return code;
 }
 /** A file a remote caller sent with the request, by the argument that names it; never a path on this machine. */
@@ -1307,7 +1310,9 @@ async function readyCommand(flags, context) {
             write(`  ${task.id}  ${task.title}`);
         return EXIT.ok;
     }
-    const ready = store.listReady(now);
+    // A remote person limited to some projects (remoteLensOf) sees only theirs, counted over those alone.
+    const lens = context.principal?.lens ?? null;
+    const ready = store.listReady(now).filter(ref => lens === null || ref.repo !== null && lens.includes(ref.repo));
     const described = ready.map(ref => describeRef(store, ref, now));
     const dispatchableCount = described.filter(one => diagnosisIsDispatchable(one.dispatch)).length;
     const pauses = openAuthPauses(store);
@@ -10097,6 +10102,13 @@ async function statusCommand(positional, flags, context) {
         return fail(context.write, context.json, command, "usage", "Use `toolroll status [--json]`.", EXIT.usage);
     // Whose lead the status line follows: the lead's own person, else the remembered login; nobody shows no lead.
     const viewer = currentActor()?.account ?? readLoginFile(join(dirname(context.databaseFile), UP_LOGIN_FILE))?.name ?? null;
+    // A remote person limited to some projects sees only those (remoteLensOf): their tasks and counts, and nothing
+    // that belongs to the installation or other projects (updates, integrations, builds by project, unsent replies).
+    const lens = context.principal?.lens ?? null;
+    if (lens !== null) {
+        const status = installationStatus(context.store, context.clock(), viewer, lens);
+        return succeed(context.write, context.json, command, { ...status, projects: [] }, () => renderInstallationStatus(status, true));
+    }
     const status = installationStatus(context.store, context.clock(), viewer);
     // One line, only when a newer Toolroll exists; offline or switched off says nothing.
     const current = PACKAGE_VERSION;
@@ -10427,6 +10439,7 @@ async function addTask(positional, flags, context) {
             throw new RemoteRefusal("not-found", "Not found.");
         }
     }
+    remote?.noteTask(filedId);
     store.stampFiledVia(store.refFor(BUILT_IN, filedId).id, "cli");
     // Placement is explicit, never inferred from where the command happened to
     // run: a task filed from the wrong directory would silently bind to it.
@@ -10707,7 +10720,9 @@ function listTasks(flags, context) {
     }
     let page;
     try {
-        page = workIndexPage(store, now, { principal: 'operator', repos: null, includeUnplaced: true }, {
+        // A remote person limited to some projects (remoteLensOf) pages and counts only theirs.
+        const lens = context.principal?.lens ?? null;
+        page = workIndexPage(store, now, { principal: 'operator', repos: lens, includeUnplaced: lens === null }, {
             view: parseWorkView(rawView ?? null), limit, cursor: text(flags, 'cursor') ?? null,
             ...(wanted === undefined ? {} : { state: wanted }),
             ...(text(flags, 'repo') === undefined ? {} : { project: text(flags, 'repo') }),
@@ -10754,13 +10769,21 @@ function showTask(positional, context) {
     // whatever readiness this task's runners have reported.
     const routed = routeOfTask(store, id, ref, now);
     const readiness = store.readinessLookupFor(ref.repo, ref.assignedRunner, now);
+    const lens = context.principal?.lens ?? null;
+    const access = { principal: "operator", repos: lens, includeUnplaced: lens === null, dependencyRepos: lens };
+    const blockers = store.blockers(id);
+    const visibleBlockers = lens === null ? blockers : blockers.filter(blocker => {
+        const repo = store.lookupRef(blocker)?.repo;
+        return repo != null && lens.includes(repo);
+    });
     const detail = {
         task,
-        work: taskWorkSummaryOf(store, id, now, { principal: "operator", repos: null, includeUnplaced: true }),
-        assignment: assignmentBrief(assignmentOf(store, id, now, { principal: "operator", repos: null, includeUnplaced: true }, context.evidenceRoot)),
+        work: taskWorkSummaryOf(store, id, now, access),
+        assignment: assignmentBrief(assignmentOf(store, id, now, access, context.evidenceRoot)),
         ref: ref.id,
-        blockedBy: store.blockers(id),
-        position: store.queuePosition(id),
+        // One phrase for every inaccessible blocker, so even their number stays private.
+        blockedBy: visibleBlockers.length === blockers.length ? visibleBlockers : [...visibleBlockers, "a task in another project"],
+        position: lens === null ? store.queuePosition(id) : null,
         reservedFor: ref.assignedRunner,
         hold: store.activeHold(ref.id, now),
         claim: currentClaim(store, ref.id, now),
@@ -10785,7 +10808,7 @@ function showTask(positional, context) {
         // The one automatic review of the latest build: HIGH findings, suggested
         // follow-ups (MEDIUM/LOW), or why it was not reviewed.
         automaticReview: latestFinished === null ? null : buildReviewOf(store, latestFinished.id),
-        dispatch: diagnoseTaskDispatch(store, id, now),
+        dispatch: diagnoseTaskDispatch(store, id, now, lens),
         // v52: the exact-run control the console shows — Stop, Stopping,
         // Paused (resume), or the review-retry door — and every stop on record.
         control: taskControlOf(store, ref.id, now),

package/dist/remote-run.d.ts

@@ -8,6 +8,10 @@ export type RemoteRun = {
     readonly secret: string;
     /** Whether the person may use `repo` now (their token's projects and their account's current access). */
     readonly allows: (repo: string | null) => boolean;
+    /** The projects listings and task references may disclose (remoteLensOf); null shows every project. */
+    readonly lens: readonly string[] | null;
+    /** Called with the task a remote `task add` filed (or replayed), so its action history names it. */
+    readonly noteTask: (taskId: string) => void;
     /** Files the caller sent, keyed by the argument that names them. Nothing else is read for input. */
     readonly files: Readonly<Record<string, string>>;
 };

package/dist/work-summary.d.ts

@@ -41,7 +41,7 @@ export declare function openWorkDecisionOf(store: Store, taskRef: number, now: D
 export declare function workDecisionAction(taskId: string, decision: NonNullable<WorkFacts["openDecision"]>, principal: WorkPrincipal): WorkAction;
 /** Pure counterpart for callers already holding the same facts. */
 export declare function workSummaryOf(facts: WorkFacts, principal: WorkPrincipal, resultDisplay?: DisplayStatus): WorkSummary;
-export type WorkSummaryAccess = 
+export type WorkSummaryAccess = (
 /** `viewer`: the person reading, whose own lead's claim (lead-voice.ts) a task reads as "<name> is on it". */
 {
     principal: "operator";
@@ -51,6 +51,9 @@ export type WorkSummaryAccess =
 } | {
     principal: "coordinator";
     repos: readonly string[];
+}) & {
+    /** Remote task reads also restrict dependency details; omitted preserves existing local output. */
+    dependencyRepos?: readonly string[] | null;
 };
 /** Admission precedes reading question/proof bodies. Missing and foreign
  * tasks share the same result. The caller must authenticate/revalidate

package/dist/work-summary.js

@@ -94,7 +94,7 @@ export function taskWorkSummaryOf(store, taskId, now, access) {
     const publication = result === null ? null : store.publicationForRun(result.id);
     const facts = {
         id: task.id, title: task.title, repo: ref.repo, state: task.state, updatedAt: task.updatedAt,
-        dispatch: diagnoseTaskDispatch(store, taskId, now), liveRunId: live?.id ?? null,
+        dispatch: diagnoseTaskDispatch(store, taskId, now, access.dependencyRepos ?? null), liveRunId: live?.id ?? null,
         unfinishedRunId: runs.find(one => one.outcome === null && one.role !== "reviewer")?.id ?? null,
         control: taskControlOf(store, ref.id, now), openDecision: openWorkDecisionOf(store, ref.id, now),
         result: result === null ? null : {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolroll",
-  "version": "0.9.44",
+  "version": "0.9.45",
   "description": "A control plane for unattended coding agents — queue tasks, walk away, come back to pull requests. Agents build in leased worktrees, never touch your default branch, and interrupt you only for decisions that need a human.",
   "directories": {
     "doc": "docs"