@skrr-ai/cli 0.1.43 → 0.1.44

package/dist/lib/first-party-harness-agent.js

@@ -55,18 +55,26 @@ exports.resolveFirstPartyHarnessAgent = resolveFirstPartyHarnessAgent;
 exports.readConfiguredAgentId = readConfiguredAgentId;
 exports.setConfiguredAgentId = setConfiguredAgentId;
 exports.clearConfiguredAgentId = clearConfiguredAgentId;
+exports.collectRosterPages = collectRosterPages;
 const auth_core_1 = require("@skrr-ai/auth-core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const api_fetch_1 = require("./api-fetch");
 const config_1 = require("./config");
 const first_party_harness_managed_1 = require("./first-party-harness-managed");
+/** Page size for one `/api/agents` roster request. */
+const ROSTER_PAGE_SIZE = 100;
 /**
- * How many agents the refusal is allowed to look at.
+ * The most agents the roster will read, across pages.
  *
- * A bound rather than pagination: this list exists to answer "did you mean one of
- * these?", and a user with more agents than this is a user who will pass the flag.
+ * The roster is not only the refusal's "did you mean" list. Resolution also finds
+ * the user's EXISTING default agent in it (`createDefault: false`) and matches a
+ * configured agent by name, so one fixed page answered "you have no default agent"
+ * for an account whose default was agent 198 of 210 (found by the end-to-end run
+ * on 2026-09-17). Pages are followed until the server says there are no more, up
+ * to this bound, which keeps a pathological account from turning one session
+ * start into an unbounded crawl.
  */
-const ROSTER_LIMIT = 100;
+const ROSTER_MAX = 1000;
 /** How many candidates a refusal prints before it summarizes the rest. */
 const CANDIDATES_SHOWN = 12;
 class FirstPartyHarnessAgentError extends Error {
@@ -369,14 +377,35 @@ function writeConfigKey(id) {
  * `fields=summary` drops the prompt-sized fields; this needs an id and a name.
  */
 async function listAgents(signal) {
-    const response = await (0, api_fetch_1.apiFetch)(`/api/agents?limit=${ROSTER_LIMIT}&fields=summary&requiredPermission=${data_provider_1.PermissionBits.EDIT}`, signal ? { signal } : {});
-    if (Array.isArray(response))
-        return response;
-    if (Array.isArray(response?.data))
-        return response.data;
-    if (Array.isArray(response?.agents))
-        return response.agents;
-    return [];
+    return collectRosterPages((cursor) => (0, api_fetch_1.apiFetch)(`/api/agents?limit=${ROSTER_PAGE_SIZE}&fields=summary&requiredPermission=${data_provider_1.PermissionBits.EDIT}` +
+        (cursor ? `&cursor=${encodeURIComponent(cursor)}` : ''), signal ? { signal } : {}));
+}
+/**
+ * Read roster pages until the server reports no more, up to `max` rows.
+ *
+ * A page that does not say `has_more` with a usable `after` cursor ends the walk,
+ * so an older server that ignores `cursor` (or returns a bare array) costs exactly
+ * the one request it always did.
+ */
+async function collectRosterPages(fetchPage, max = ROSTER_MAX) {
+    const rows = [];
+    let cursor;
+    do {
+        const response = await fetchPage(cursor);
+        const page = Array.isArray(response)
+            ? response
+            : Array.isArray(response?.data)
+                ? response.data
+                : Array.isArray(response?.agents)
+                    ? response.agents
+                    : [];
+        rows.push(...page);
+        const next = !Array.isArray(response) && response?.has_more === true && typeof response.after === 'string'
+            ? response.after
+            : undefined;
+        cursor = next && next !== cursor && page.length > 0 ? next : undefined;
+    } while (cursor && rows.length < max);
+    return rows.slice(0, max);
 }
 /**
  * The caller's own user id, memoized FOR THIS PROCESS ONLY.

package/dist/lib/first-party-harness-doctor.js

@@ -263,8 +263,16 @@ function stateDirCheck(cwd, env) {
             remedy: `This is a build bug — report it. Do not run ${auth_core_1.FIRST_PARTY_HARNESS.displayName} from this directory.`,
         };
     }
+    // The engine still reads a project directory under a legacy namespace, after the
+    // current one (OSK-8674); one that exists is worth naming, or "not created yet"
+    // reads as "no project config" on a repository that has some.
+    const legacyProjects = (0, auth_core_1.firstPartyHarnessEngineProjectDirectories)()
+        .slice(1)
+        .map((directory) => node_path_1.default.join(node_path_1.default.resolve(cwd), directory))
+        .filter((directory) => (0, node_fs_1.existsSync)(directory));
     const parts = [
         `project: ${project}${(0, node_fs_1.existsSync)(project) ? '' : ' (not created yet)'}`,
+        ...legacyProjects.map((directory) => `also read (legacy): ${directory}`),
         `user: ${user}${(0, node_fs_1.existsSync)(user) ? '' : ' (not created yet)'}`,
     ];
     return { name: 'state-paths', status: 'ok', detail: parts.join('; ') };
@@ -306,21 +314,29 @@ function compatCheck(cwd, env) {
     // session only when the daemon links them in, which `skrr skills local` shows.
     const root = node_path_1.default.resolve(cwd);
     const home = env.HOME || (0, node_os_1.homedir)();
-    const projectDir = auth_core_1.FIRST_PARTY_HARNESS_ENGINE.projectDirectory;
-    const noCompatPrompts = Boolean(env[auth_core_1.FIRST_PARTY_HARNESS_ENGINE.env.noCompatPrompts]);
+    // The engine reads its variables under every namespace it has had, current first.
+    const noCompatPrompts = (0, auth_core_1.readFirstPartyHarnessEngineEnv)(env, 'noCompatPrompts').name;
     const engineHomeDir = (0, first_party_harness_1.engineInstructionHome)(env);
     const shown = (abs) => abs.startsWith(root + node_path_1.default.sep)
         ? node_path_1.default.relative(root, abs)
         : abs.startsWith(home + node_path_1.default.sep)
             ? `~/${node_path_1.default.relative(home, abs)}`
             : abs;
+    // The engine's project instruction file under every project directory it reads,
+    // current first. It reads the first that exists, so a legacy one beside a current
+    // one is present and NOT read — said, rather than listed as if it applied.
+    const projectInstructions = (0, auth_core_1.firstPartyHarnessEngineProjectDirectories)().map((directory) => node_path_1.default.join(root, directory, 'AGENTS.md'));
     const declared = [
-        {
-            abs: node_path_1.default.join(root, projectDir, 'AGENTS.md'),
-            kind: 'instructions',
-            owner: 'engine',
-            scope: 'project',
-        },
+        ...projectInstructions.map((abs, i) => {
+            const newer = projectInstructions.slice(0, i).find((candidate) => (0, node_fs_1.existsSync)(candidate));
+            return {
+                abs,
+                kind: 'instructions',
+                owner: 'engine',
+                scope: 'project',
+                ...(newer ? { disabled: `superseded by ${node_path_1.default.relative(root, newer)}` } : {}),
+            };
+        }),
         {
             abs: node_path_1.default.join(engineHomeDir, 'AGENTS.md'),
             kind: 'instructions',
@@ -338,14 +354,14 @@ function compatCheck(cwd, env) {
             kind: 'instructions',
             owner: 'compatibility',
             scope: 'project',
-            ...(noCompatPrompts ? { disabled: auth_core_1.FIRST_PARTY_HARNESS_ENGINE.env.noCompatPrompts } : {}),
+            ...(noCompatPrompts ? { disabled: noCompatPrompts } : {}),
         },
         {
             abs: node_path_1.default.join(home, '.claude', 'CLAUDE.md'),
             kind: 'instructions',
             owner: 'compatibility',
             scope: 'user',
-            ...(noCompatPrompts ? { disabled: auth_core_1.FIRST_PARTY_HARNESS_ENGINE.env.noCompatPrompts } : {}),
+            ...(noCompatPrompts ? { disabled: noCompatPrompts } : {}),
         },
         {
             abs: node_path_1.default.join(root, '.agents', 'skills'),
@@ -494,15 +510,17 @@ const EGRESS_DENIED_HOSTS = [
     'social-cards.sst.dev',
     'opencode.internal',
 ];
-/** The ENGINE reads this one under its own name; the platform only reports it. */
-const EGRESS_OVERRIDE_ENV = auth_core_1.FIRST_PARTY_HARNESS_ENGINE.env.allowUpstreamEgress;
+/**
+ * The ENGINE reads this one under its own names, current namespace first; the
+ * platform only reports it, naming the variable that actually supplied it.
+ */
 function egressCheck(env) {
-    const override = env[EGRESS_OVERRIDE_ENV];
-    if (override === '1' || override === 'true') {
+    const override = (0, auth_core_1.readFirstPartyHarnessEngineEnv)(env, 'allowUpstreamEgress');
+    if (override.value === '1' || override.value === 'true') {
         return {
             name: 'upstream-egress',
             status: 'warn',
-            detail: `${EGRESS_OVERRIDE_ENV} is set — ${auth_core_1.FIRST_PARTY_HARNESS.displayName} may reach upstream hosted services`,
+            detail: `${override.name} is set — ${auth_core_1.FIRST_PARTY_HARNESS.displayName} may reach upstream hosted services`,
             remedy: 'Unset it unless you are deliberately debugging upstream behaviour. Session content, ' +
                 'repository names, and account tokens can leave for a third party while it is set.',
         };
@@ -746,7 +764,7 @@ function sessionAuthorityCheck(env) {
                 remedy: 'Intended for local use, and nothing to fix. Worth knowing because it is NOT the same ' +
                     'trust plane as a daemon-dispatched run — and neither plane is an OS-level sandbox ' +
                     '(no seccomp, container, or namespace). An untrusted autonomous workload needs a hosted ' +
-                    `or container profile; see docs/${auth_core_1.FIRST_PARTY_HARNESS_ENGINE.appName}/threat-model.md in the engine's repository.`,
+                    "or container profile; see the threat model in the engine's repository.",
             };
     }
 }

package/dist/lib/first-party-harness.d.ts

@@ -47,11 +47,13 @@ export declare function engineHome(env?: NodeJS.ProcessEnv): string;
  * The user-level instruction root the engine owns.
  *
  * Read under the platform's neutral variable first, then under the variable the
- * ENGINE itself reads (`FIRST_PARTY_HARNESS_ENGINE.env.home`). The second is not a
- * legacy fallback: it is the engine's own name, the engine honours it whatever the
- * platform does, and a CLI that ignored it would report one instruction root while
- * the engine it launches used another. {@link engineOwnedEnv} closes the other
- * direction, handing a neutral-variable value to the engine under its own name.
+ * ENGINE itself reads, under every name it reads it by, current namespace first
+ * (`readFirstPartyHarnessEngineEnv(env, 'home')`; the namespace moved in OSK-8674
+ * and the engine reads both). That is not a legacy fallback: it is the engine's own
+ * variable, the engine honours it whatever the platform does, and a CLI that
+ * ignored it would report one instruction root while the engine it launches used
+ * another. {@link engineOwnedEnv} closes the other direction, handing a
+ * neutral-variable value to the engine under its own names.
  */
 export declare function engineInstructionHome(env?: NodeJS.ProcessEnv): string;
 /**
@@ -378,12 +380,17 @@ export declare function engineSpawnEnv(env: NodeJS.ProcessEnv, extraEnv: Record<
  * `skrr code doctor` honour it while the engine it launches ignored it — two
  * answers to "where do my instructions live" from one command.
  *
- * Only when the neutral variable supplied the value: a value set only under the
- * engine's own name is inherited already, and rewriting it would only replace the
- * user's spelling of a path with ours. When both are set the neutral one wins, as
- * it does in {@link engineInstructionHome}, so the engine is handed that one. The
- * resolved path is passed rather than the raw value, so the engine and the doctor
- * agree on `~` expansion too.
+ * Under EVERY name the engine has read (`firstPartyHarnessEngineEnvEntries`). The
+ * engine's namespace moved (OSK-8674), and the binary this CLI launches may be a
+ * build from either side of that move; a value handed over under one name only
+ * reaches half of them.
+ *
+ * When the neutral variable supplied the value, every engine name gets it: the
+ * neutral one wins, as it does in {@link engineInstructionHome}. When only an
+ * engine name did, only the engine names that are UNSET are filled in — the user's
+ * own values are inherited already, and two different values the user set under
+ * two names are theirs to keep. The resolved path is passed rather than the raw
+ * value, so the engine and the doctor agree on `~` expansion too.
  *
  * Not a credential and never one: it cannot reintroduce anything the sanitizer
  * strips, and `extraEnv` still layers over it.

package/dist/lib/first-party-harness.js

@@ -84,14 +84,17 @@ function engineHome(env = process.env) {
  * The user-level instruction root the engine owns.
  *
  * Read under the platform's neutral variable first, then under the variable the
- * ENGINE itself reads (`FIRST_PARTY_HARNESS_ENGINE.env.home`). The second is not a
- * legacy fallback: it is the engine's own name, the engine honours it whatever the
- * platform does, and a CLI that ignored it would report one instruction root while
- * the engine it launches used another. {@link engineOwnedEnv} closes the other
- * direction, handing a neutral-variable value to the engine under its own name.
+ * ENGINE itself reads, under every name it reads it by, current namespace first
+ * (`readFirstPartyHarnessEngineEnv(env, 'home')`; the namespace moved in OSK-8674
+ * and the engine reads both). That is not a legacy fallback: it is the engine's own
+ * variable, the engine honours it whatever the platform does, and a CLI that
+ * ignored it would report one instruction root while the engine it launches used
+ * another. {@link engineOwnedEnv} closes the other direction, handing a
+ * neutral-variable value to the engine under its own names.
  */
 function engineInstructionHome(env = process.env) {
-    const configured = (0, auth_core_1.readFirstPartyHarnessEnv)(env, 'home').value ?? engineHomeVariable(env);
+    const configured = (0, auth_core_1.readFirstPartyHarnessEnv)(env, 'home').value ??
+        (0, auth_core_1.readFirstPartyHarnessEngineEnv)(env, 'home').value;
     // Falls through to `engineHome()` rather than re-deriving `~/.skrr` — the two
     // describe the same root, and re-deriving it is what made them disagree under
     // `OVERSKY_CONFIG_DIR` (OSK-300).
@@ -103,11 +106,6 @@ function engineInstructionHome(env = process.env) {
         return node_path_1.default.join((0, node_os_1.homedir)(), configured.slice(2));
     return node_path_1.default.resolve(configured);
 }
-/** The engine's own home variable, trimmed; undefined when unset or blank. */
-function engineHomeVariable(env) {
-    const raw = env[auth_core_1.FIRST_PARTY_HARNESS_ENGINE.env.home];
-    return typeof raw === 'string' && raw.trim() !== '' ? raw.trim() : undefined;
-}
 /**
  * The managed install location for one spelling of the binary (canonical by
  * default) — where the daemon, the Desktop app, and
@@ -142,7 +140,7 @@ function legacyManagedEnginePaths(env = process.env) {
 function legacyManagedEngineBinDirs(env = process.env) {
     if ((0, auth_core_1.isConfigRootOverridden)(env))
         return [];
-    return [(0, auth_core_1.firstPartyHarnessHomeDirname)(), ...auth_core_1.FIRST_PARTY_HARNESS_ENGINE.legacyAppNames].map((home) => node_path_1.default.join((0, config_1.priorConfigDir)(), home, 'bin'));
+    return (0, auth_core_1.firstPartyHarnessEngineHomeDirnames)().map((home) => node_path_1.default.join((0, config_1.priorConfigDir)(), home, 'bin'));
 }
 /**
  * Unmanaged well-known locations, checked after PATH.
@@ -606,22 +604,29 @@ mode) {
  * `skrr code doctor` honour it while the engine it launches ignored it — two
  * answers to "where do my instructions live" from one command.
  *
- * Only when the neutral variable supplied the value: a value set only under the
- * engine's own name is inherited already, and rewriting it would only replace the
- * user's spelling of a path with ours. When both are set the neutral one wins, as
- * it does in {@link engineInstructionHome}, so the engine is handed that one. The
- * resolved path is passed rather than the raw value, so the engine and the doctor
- * agree on `~` expansion too.
+ * Under EVERY name the engine has read (`firstPartyHarnessEngineEnvEntries`). The
+ * engine's namespace moved (OSK-8674), and the binary this CLI launches may be a
+ * build from either side of that move; a value handed over under one name only
+ * reaches half of them.
+ *
+ * When the neutral variable supplied the value, every engine name gets it: the
+ * neutral one wins, as it does in {@link engineInstructionHome}. When only an
+ * engine name did, only the engine names that are UNSET are filled in — the user's
+ * own values are inherited already, and two different values the user set under
+ * two names are theirs to keep. The resolved path is passed rather than the raw
+ * value, so the engine and the doctor agree on `~` expansion too.
  *
  * Not a credential and never one: it cannot reintroduce anything the sanitizer
  * strips, and `extraEnv` still layers over it.
  */
 function engineOwnedEnv(env) {
-    const out = {};
+    const everyName = (value) => (0, auth_core_1.firstPartyHarnessEngineEnvEntries)('home', value);
     if ((0, auth_core_1.readFirstPartyHarnessEnv)(env, 'home').value) {
-        out[auth_core_1.FIRST_PARTY_HARNESS_ENGINE.env.home] = engineInstructionHome(env);
+        return everyName(engineInstructionHome(env));
     }
-    return out;
+    if (!(0, auth_core_1.readFirstPartyHarnessEngineEnv)(env, 'home').value)
+        return {};
+    return Object.fromEntries(Object.entries(everyName(engineInstructionHome(env))).filter(([name]) => !(typeof env[name] === 'string' && env[name].trim() !== '')));
 }
 async function execEngine(args, env = process.env, options = {}) {
     // Move an engine installed under an older binary name onto the canonical one,

package/dist/lib/harnesses.d.ts

@@ -101,6 +101,12 @@ export interface HarnessLease {
     machineProduct?: string;
     machineProductLabel?: string;
     displayName?: string;
+    /**
+     * Who pays: the workspace whose account the lease bills, or `null` for the
+     * owner's personal account (`MachineLease.toSafeJSON`). Absent from a server
+     * that predates it, which is not the same as personal.
+     */
+    workspaceId?: string | null;
     state?: string;
     stateReason?: string;
     lifecycleSemantics?: string;

package/dist/lib/instruction-input.d.ts

@@ -76,6 +76,27 @@ export declare function describeTargetSync(target: {
     updatedAt?: string;
     driftCount?: number;
 }, now?: number, liveDaemonIds?: string[]): string;
+/**
+ * The whole error of every failed target, and what to do about it.
+ *
+ * The STATUS column caps at 78 characters, so a daemon error that names a path
+ * was cut mid-path — "must be inside a Git repository: /private/…" — and the
+ * table offered nothing past it: no remedy, and no way to learn that
+ * `instructions remove` was the way out (OSK-4626). The column keeps its cap;
+ * the full sentence and the next step go below the table, the way the re-bind
+ * commands do.
+ *
+ * The daemon retries a failed target on its next sync (every five minutes, or
+ * sooner on any change), so fixing the cause is itself a remedy and needs no
+ * command. A failed REMOVAL is the other case: it can only be abandoned when
+ * its daemon is gone, which is the one place `purge-target --force` belongs.
+ */
+export declare function failedTargetLines(targets: Array<{
+    id: string;
+    status?: string;
+    desiredState?: string;
+    lastError?: string;
+}>, bin?: string): string[];
 /**
  * The command that re-binds a stalled target to the daemon now running on its
  * machine, or null when no such daemon is live.

package/dist/lib/instruction-input.js

@@ -7,6 +7,7 @@ exports.resolveBundleLabel = resolveBundleLabel;
 exports.parseDaemonId = parseDaemonId;
 exports.sameMachineDaemon = sameMachineDaemon;
 exports.describeTargetSync = describeTargetSync;
+exports.failedTargetLines = failedTargetLines;
 exports.rebindCommandFor = rebindCommandFor;
 const promises_1 = require("node:fs/promises");
 async function readStdin() {
@@ -188,6 +189,35 @@ function describeTargetSync(target, now = Date.now(), liveDaemonIds = []) {
     }
     return `${base} — stalled ${days}d; daemon may be gone: remove, then purge-target --force`;
 }
+/**
+ * The whole error of every failed target, and what to do about it.
+ *
+ * The STATUS column caps at 78 characters, so a daemon error that names a path
+ * was cut mid-path — "must be inside a Git repository: /private/…" — and the
+ * table offered nothing past it: no remedy, and no way to learn that
+ * `instructions remove` was the way out (OSK-4626). The column keeps its cap;
+ * the full sentence and the next step go below the table, the way the re-bind
+ * commands do.
+ *
+ * The daemon retries a failed target on its next sync (every five minutes, or
+ * sooner on any change), so fixing the cause is itself a remedy and needs no
+ * command. A failed REMOVAL is the other case: it can only be abandoned when
+ * its daemon is gone, which is the one place `purge-target --force` belongs.
+ */
+function failedTargetLines(targets, bin = 'skrr') {
+    const failed = targets.filter((target) => target.status === 'error');
+    if (failed.length === 0)
+        return [];
+    const lines = ['', 'Failed targets:'];
+    for (const target of failed) {
+        const removing = target.desiredState === 'removed';
+        lines.push(`  ${target.id} — ${removing ? 'removal failed' : 'install failed'}: ${target.lastError || 'no reason reported'}`);
+        lines.push(removing
+            ? `    Fix the cause and its daemon retries on the next sync. If that daemon is gone for good: \`${bin} instructions purge-target ${target.id} --force\``
+            : `    Fix the cause and its daemon retries on the next sync, or drop the target: \`${bin} instructions remove ${target.id}\``);
+    }
+    return lines;
+}
 /**
  * The command that re-binds a stalled target to the daemon now running on its
  * machine, or null when no such daemon is live.

package/dist/lib/instruction-provenance.d.ts

@@ -0,0 +1,54 @@
+/**
+ * instruction-provenance.ts — tell a prompt's two version counters apart.
+ *
+ * A managed instruction prompt has its OWN version counter (1, 2, 3 — every
+ * saved body), and a prompt installed from a built-in template also carries
+ * the TEMPLATE release each body came from (1, 2, 5, 17 — skipping whatever an
+ * install never received). Every table labelled both `v`, and they agree only
+ * by coincidence: bundle v3 was built-in v5 on the installation that found this
+ * (dogfood OSK-4647), so "the preset went to v5" read as two versions behind.
+ * The provenance that settles it (`sourceTemplateKey`/`sourceTemplateVersion`)
+ * was reachable through `--json` alone.
+ *
+ * So the prompt's counter stays `v<n>`, and a template release is always
+ * written `built-in v<n>` — never a bare `v` that could be either.
+ */
+export interface TemplateProvenance {
+    sourceTemplateKey?: string;
+    sourceTemplateVersion?: number;
+}
+/**
+ * `built-in v5` for a body taken from a built-in template, `built-in` when the
+ * row is recognised as one but its release was never derivable (the provenance
+ * backfill stamps the key without inventing a number), and `` for a body that
+ * was not taken from a template at all.
+ */
+export declare function builtInLabel(version: TemplateProvenance | null | undefined): string;
+interface VersionLike extends TemplateProvenance {
+    versionNumber?: number;
+}
+interface BundleLike extends TemplateProvenance {
+    currentVersionNumber?: number;
+    currentVersion?: VersionLike | null;
+}
+/**
+ * The APPLIED cell of `instructions status`: `v3 (built-in v5)` when the
+ * applied body is the prompt's current one and that one came from a template.
+ * Only then is the release known without fetching the version history, so any
+ * other case says `v3` and nothing it cannot back.
+ */
+export declare function appliedVersionLabel(appliedVersionNumber: number | undefined, bundle: BundleLike | undefined): string;
+/**
+ * One sentence for `instructions show`: which built-in template a prompt comes
+ * from, whether its current body IS a built-in release, and whether a newer
+ * release exists — the question no command answered before. `STATUS: available`
+ * on a version row means "not archived", not "newer than yours".
+ *
+ * `latestTemplateVersion` is the release this server would install today;
+ * undefined when it could not be read, in which case nothing is claimed about
+ * it. Returns null for a prompt that was not installed from a template.
+ */
+export declare function describeTemplateProvenance(bundle: BundleLike & {
+    currentVersionNumber: number;
+}, latestTemplateVersion?: number): string | null;
+export {};

package/dist/lib/instruction-provenance.js

@@ -0,0 +1,84 @@
+"use strict";
+/**
+ * instruction-provenance.ts — tell a prompt's two version counters apart.
+ *
+ * A managed instruction prompt has its OWN version counter (1, 2, 3 — every
+ * saved body), and a prompt installed from a built-in template also carries
+ * the TEMPLATE release each body came from (1, 2, 5, 17 — skipping whatever an
+ * install never received). Every table labelled both `v`, and they agree only
+ * by coincidence: bundle v3 was built-in v5 on the installation that found this
+ * (dogfood OSK-4647), so "the preset went to v5" read as two versions behind.
+ * The provenance that settles it (`sourceTemplateKey`/`sourceTemplateVersion`)
+ * was reachable through `--json` alone.
+ *
+ * So the prompt's counter stays `v<n>`, and a template release is always
+ * written `built-in v<n>` — never a bare `v` that could be either.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.builtInLabel = builtInLabel;
+exports.appliedVersionLabel = appliedVersionLabel;
+exports.describeTemplateProvenance = describeTemplateProvenance;
+/**
+ * `built-in v5` for a body taken from a built-in template, `built-in` when the
+ * row is recognised as one but its release was never derivable (the provenance
+ * backfill stamps the key without inventing a number), and `` for a body that
+ * was not taken from a template at all.
+ */
+function builtInLabel(version) {
+    if (!version?.sourceTemplateKey)
+        return '';
+    const release = version.sourceTemplateVersion;
+    return Number.isInteger(release) && Number(release) > 0 ? `built-in v${release}` : 'built-in';
+}
+/**
+ * The APPLIED cell of `instructions status`: `v3 (built-in v5)` when the
+ * applied body is the prompt's current one and that one came from a template.
+ * Only then is the release known without fetching the version history, so any
+ * other case says `v3` and nothing it cannot back.
+ */
+function appliedVersionLabel(appliedVersionNumber, bundle) {
+    if (!appliedVersionNumber)
+        return '-';
+    const base = `v${appliedVersionNumber}`;
+    const current = bundle?.currentVersion;
+    if (!current || current.versionNumber !== appliedVersionNumber)
+        return base;
+    const builtIn = builtInLabel(current);
+    return builtIn ? `${base} (${builtIn})` : base;
+}
+/**
+ * One sentence for `instructions show`: which built-in template a prompt comes
+ * from, whether its current body IS a built-in release, and whether a newer
+ * release exists — the question no command answered before. `STATUS: available`
+ * on a version row means "not archived", not "newer than yours".
+ *
+ * `latestTemplateVersion` is the release this server would install today;
+ * undefined when it could not be read, in which case nothing is claimed about
+ * it. Returns null for a prompt that was not installed from a template.
+ */
+function describeTemplateProvenance(bundle, latestTemplateVersion) {
+    if (!bundle.sourceTemplateKey)
+        return null;
+    const current = bundle.currentVersion;
+    const head = `From built-in template ${bundle.sourceTemplateKey}.`;
+    if (!current)
+        return head;
+    const release = current.sourceTemplateKey ? current.sourceTemplateVersion : undefined;
+    const version = `v${bundle.currentVersionNumber}`;
+    const latestKnown = Number.isInteger(latestTemplateVersion);
+    if (current.sourceTemplateKey) {
+        const builtIn = builtInLabel(current);
+        if (!latestKnown || !Number.isInteger(release))
+            return `${head} ${version} is ${builtIn}.`;
+        if (Number(latestTemplateVersion) > Number(release)) {
+            return `${head} ${version} is ${builtIn}; built-in v${latestTemplateVersion} is newer.`;
+        }
+        return `${head} ${version} is ${builtIn}, the latest.`;
+    }
+    // Newer releases are promoted only onto a prompt whose body is still a
+    // built-in one, so an edit is exactly when "is there a newer one" matters.
+    const edited = `${head} ${version} is your own edit, so newer built-in releases are not applied to it`;
+    return latestKnown
+        ? `${edited}; the latest is built-in v${latestTemplateVersion}.`
+        : `${edited}.`;
+}

package/dist/lib/task-view-render.d.ts

@@ -13,12 +13,15 @@
  * go.
  */
 export interface TaskViewFilters {
+    quickFilter?: string;
     statuses?: string[];
+    statusTypes?: string[];
     priorities?: string[];
     assignees?: string[];
     labels?: string[];
     goalIds?: string[];
     projectIds?: string[];
+    cycleIds?: string[];
     search?: string;
 }
 export interface TaskViewLike {
@@ -69,3 +72,14 @@ export declare function immutableViewPatchKeys(body: Record<string, unknown>): s
  * than listing six empty ones.
  */
 export declare function describeTaskView(view: TaskViewLike): string[];
+/**
+ * One line saying what a view SELECTS, for a table cell.
+ *
+ * `views list` had a SELECTION column whose value was the word `criteria` for
+ * every view that was not a pinned task list — a kind label sitting where the
+ * reader looks for an answer (dogfood OSK-4646). Values that fit are named
+ * (statuses, priorities, the quick filter, the search); ids are counted, since
+ * a row of UUIDs answers nothing at a glance and `views show` prints them in
+ * full.
+ */
+export declare function summarizeTaskViewSelection(view: TaskViewLike): string;

package/dist/lib/task-view-render.js

@@ -18,6 +18,12 @@ exports.EDITABLE_VIEW_PATCH_FIELDS = void 0;
 exports.unshareableViewWarning = unshareableViewWarning;
 exports.immutableViewPatchKeys = immutableViewPatchKeys;
 exports.describeTaskView = describeTaskView;
+exports.summarizeTaskViewSelection = summarizeTaskViewSelection;
+/** `all` is the quick filter that filters nothing; any other one narrows. */
+function narrowingQuickFilter(filters) {
+    const quick = filters.quickFilter;
+    return quick && quick !== 'all' ? quick : undefined;
+}
 /**
  * OSK-4859 — a view created with no active workspace comes back with no
  * `workspaceId`, and the server then refuses to share it
@@ -97,13 +103,20 @@ function describeTaskView(view) {
         add('pinned tasks', `${pinned.length}: ${pinned.join(', ')}`);
     }
     const f = view.filters ?? {};
+    // Every selection field the create schema accepts. `--quick-filter` was a
+    // create flag this renderer never printed, so a saved quick filter was
+    // exactly the kind of selection that "did not take" invisibly.
+    const quick = narrowingQuickFilter(f);
     const filterRows = [
+        ['quick filter', quick ? [quick] : undefined],
         ['statuses', f.statuses],
+        ['status types', f.statusTypes],
         ['priorities', f.priorities],
         ['assignees', f.assignees],
         ['labels', f.labels],
         ['goals', f.goalIds],
         ['projects', f.projectIds],
+        ['cycles', f.cycleIds],
     ];
     let anyFilter = false;
     for (const [label, values] of filterRows) {
@@ -123,3 +136,45 @@ function describeTaskView(view) {
     add('sort', describeShape(view.sort));
     return lines;
 }
+const counted = (count, singular, plural = `${singular}s`) => `${count} ${count === 1 ? singular : plural}`;
+/**
+ * One line saying what a view SELECTS, for a table cell.
+ *
+ * `views list` had a SELECTION column whose value was the word `criteria` for
+ * every view that was not a pinned task list — a kind label sitting where the
+ * reader looks for an answer (dogfood OSK-4646). Values that fit are named
+ * (statuses, priorities, the quick filter, the search); ids are counted, since
+ * a row of UUIDs answers nothing at a glance and `views show` prints them in
+ * full.
+ */
+function summarizeTaskViewSelection(view) {
+    const parts = [];
+    const pinned = view.taskIds ?? [];
+    if (pinned.length)
+        parts.push(counted(pinned.length, 'pinned task'));
+    const spaces = view.spaceIds ?? [];
+    parts.push(spaces.length ? counted(spaces.length, 'space') : 'all spaces');
+    const f = view.filters ?? {};
+    const quick = narrowingQuickFilter(f);
+    if (quick)
+        parts.push(quick);
+    if (f.statuses?.length)
+        parts.push(`status ${f.statuses.join('/')}`);
+    if (f.statusTypes?.length)
+        parts.push(`status type ${f.statusTypes.join('/')}`);
+    if (f.priorities?.length)
+        parts.push(`priority ${f.priorities.join('/')}`);
+    if (f.assignees?.length)
+        parts.push(counted(f.assignees.length, 'assignee'));
+    if (f.labels?.length)
+        parts.push(counted(f.labels.length, 'label'));
+    if (f.goalIds?.length)
+        parts.push(counted(f.goalIds.length, 'goal'));
+    if (f.projectIds?.length)
+        parts.push(counted(f.projectIds.length, 'project'));
+    if (f.cycleIds?.length)
+        parts.push(counted(f.cycleIds.length, 'cycle'));
+    if (f.search)
+        parts.push(`"${f.search}"`);
+    return parts.join(', ');
+}