@sanity/ailf 3.4.1 → 3.5.1

package/dist/_vendor/ailf-shared/owner-teams.js

@@ -0,0 +1,52 @@
+/**
+ * Known owner-team slugs and soft-normalization helper.
+ *
+ * `RunOwner.team` is free-form by design (external teams name themselves
+ * and internal names drift). This module provides two things to keep UX
+ * polished without blocking new entrants:
+ *
+ *   - `KNOWN_OWNER_TEAMS` — a seed list of canonical slugs that populates
+ *     Studio filter comboboxes as suggestions. Not a closed enum.
+ *   - `normalizeOwnerTeam()` — maps a handful of common aliases to
+ *     canonical slugs. Warn-only: returns the original string when no
+ *     mapping applies. Adding an alias here is a one-liner.
+ *
+ * @see docs/decisions/D0037-run-classification-and-ownership-taxonomy.md
+ */
+export const KNOWN_OWNER_TEAMS = [
+    "content-lake",
+    "core-docs",
+    "growth",
+    "media",
+    "platform",
+    "studio",
+];
+/**
+ * Lowercase alias → canonical slug. Lightweight — only entries where
+ * drift has been observed belong here. Unknown values pass through.
+ */
+const OWNER_TEAM_ALIASES = {
+    coredocs: "core-docs",
+    docs: "core-docs",
+    studio_team: "studio",
+    "studio-team": "studio",
+};
+/**
+ * Normalize a free-form team slug to its canonical form.
+ *
+ * - Trims and lowercases.
+ * - Maps known aliases to canonical slugs.
+ * - Passes unknown values through unchanged (warn-only at the UI layer).
+ * - Returns `"unknown"` for empty input.
+ */
+export function normalizeOwnerTeam(value) {
+    if (!value)
+        return "unknown";
+    const trimmed = value.trim().toLowerCase();
+    if (!trimmed)
+        return "unknown";
+    return OWNER_TEAM_ALIASES[trimmed] ?? trimmed;
+}
+export function isKnownOwnerTeam(value) {
+    return KNOWN_OWNER_TEAMS.includes(value);
+}

package/dist/_vendor/ailf-shared/run-classification.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Run classification, ownership, executor, and environment metadata.
+ *
+ * These fields extend `RunContext` to capture run *intent*, *attribution*,
+ * and *reproducibility* — orthogonal to the *mechanism* captured by
+ * `RunTrigger`. A scheduled run can be experimental; a manual run can be
+ * official; a PR-triggered run is executed by GH Actions but attributable
+ * to the PR author.
+ *
+ * @see docs/decisions/D0037-run-classification-and-ownership-taxonomy.md
+ * @see docs/design-docs/run-classification-and-ownership.md
+ */
+/**
+ * How a run should be treated for reporting and trend tracking.
+ *
+ * Orthogonal to `RunTrigger` (mechanism). Defaults to `"ad-hoc"` when
+ * unannotated so pre-taxonomy runs never leak into the canonical series.
+ */
+export type RunClassification = "official" | "ad-hoc" | "experimental" | "test" | "external";
+export declare const RUN_CLASSIFICATIONS: readonly RunClassification[];
+export declare function isRunClassification(value: unknown): value is RunClassification;
+/**
+ * Attribution — which team and (optionally) individual the run *belongs to*.
+ *
+ * `team` is a free-form slug, not a closed enum: external teams name
+ * themselves and internal names drift. A soft-normalization layer under
+ * `config/owners.ts` maps aliases to canonical slugs (warn-only).
+ */
+export interface RunOwner {
+    team: string;
+    individual?: string;
+}
+/**
+ * Who or what actually invoked the run.
+ *
+ * Separate from `RunOwner` because they diverge for automated surfaces:
+ * a PR gate is *executed by* GH Actions but *attributable to* the PR
+ * author. Both variants expose a `name` field so consumers can format
+ * them with one template.
+ *
+ * Every detectable identity field is optional — a misconfigured shell,
+ * a container without `git`, or a CI provider that doesn't expose actor
+ * metadata can all still produce a valid run with thin provenance.
+ */
+export type RunExecutor = RunExecutorUser | RunExecutorSystem;
+export interface RunExecutorUser {
+    type: "user";
+    /** Detected from `git config user.name`, `os.userInfo().username`, or GH actor. */
+    name?: string;
+    /** From `git config user.email`. Subject to the `AILF_CAPTURE_EMAIL` opt-out. */
+    email?: string;
+    /** Where the invocation originated. Always knowable. */
+    surface: RunExecutorSurface;
+    /** GH actor when the user invoked via a GH surface (PR, manual dispatch). */
+    githubActor?: string;
+}
+export interface RunExecutorSystem {
+    type: "system";
+    /** e.g. `"github-actions"`, `"vercel-cron"`, `"sanity-webhook"`. */
+    name: string;
+    workflow?: string;
+    runId?: string;
+}
+export type RunExecutorSurface = "cli" | "studio" | "api";
+export declare const RUN_EXECUTOR_SURFACES: readonly RunExecutorSurface[];
+/**
+ * Links to related runs. Fills the gap where the Studio report schema
+ * already carried these fields but `RunContext` did not.
+ */
+export interface RunLineage {
+    /** Prior `RunId` this run re-executes. */
+    rerunOf?: string;
+    /** Sibling `RunId` this run is intentionally compared against. */
+    comparedAgainst?: string;
+    /** API-gateway job ID that dispatched this run. */
+    parentJobId?: string;
+}
+/**
+ * Reproducibility metadata — which AILF/Node ran the eval.
+ *
+ * Required on every new run so cross-version trend comparisons can
+ * isolate framework changes from doc changes.
+ */
+export interface RunTool {
+    ailfVersion: string;
+    nodeVersion: string;
+}
+/**
+ * Platform + CI-provider metadata for debugging flakes. Hostname is
+ * intentionally excluded — it leaks machine/user identity without
+ * filtering benefit.
+ */
+export interface RunHost {
+    /** `os.platform()` — `"darwin"` | `"linux"` | `"win32"`. */
+    platform: string;
+    /** `os.arch()` — `"x64"` | `"arm64"`. */
+    arch: string;
+    /** CI provider when running under one, e.g. `"github-actions"`. */
+    ci?: string;
+}

package/dist/_vendor/ailf-shared/run-classification.js

@@ -0,0 +1,28 @@
+/**
+ * Run classification, ownership, executor, and environment metadata.
+ *
+ * These fields extend `RunContext` to capture run *intent*, *attribution*,
+ * and *reproducibility* — orthogonal to the *mechanism* captured by
+ * `RunTrigger`. A scheduled run can be experimental; a manual run can be
+ * official; a PR-triggered run is executed by GH Actions but attributable
+ * to the PR author.
+ *
+ * @see docs/decisions/D0037-run-classification-and-ownership-taxonomy.md
+ * @see docs/design-docs/run-classification-and-ownership.md
+ */
+export const RUN_CLASSIFICATIONS = [
+    "official",
+    "ad-hoc",
+    "experimental",
+    "test",
+    "external",
+];
+export function isRunClassification(value) {
+    return (typeof value === "string" &&
+        RUN_CLASSIFICATIONS.includes(value));
+}
+export const RUN_EXECUTOR_SURFACES = [
+    "cli",
+    "studio",
+    "api",
+];

package/dist/_vendor/ailf-shared/run-context.d.ts

@@ -15,15 +15,26 @@
  * @see docs/design-docs/run-artifact-store.md (§ Drift Prevention)
  */
 import type { EvalMode } from "./eval-modes.js";
+import type { RunClassification, RunExecutor, RunHost, RunLineage, RunOwner, RunTool } from "./run-classification.js";
 import type { RunTrigger } from "./run-trigger.js";
 export interface RunContext {
     /** Which feature areas were evaluated */
     areas: string[];
+    /**
+     * How this run should be treated for reporting and trend tracking.
+     * Orthogonal to `trigger` (mechanism). Defaults to `"ad-hoc"` when
+     * unannotated — only the scheduled workflow mints `"official"`.
+     *
+     * @see docs/decisions/D0037-run-classification-and-ownership-taxonomy.md
+     */
+    classification: RunClassification;
     /**
      * Evaluation fingerprint — SHA-256 of all inputs that affect eval output.
      * Used for cross-environment cache lookup (CI → Content Lake).
      */
     evalFingerprint?: string;
+    /** Who/what actually invoked the run. May or may not match `owner`. */
+    executor: RunExecutor;
     /** Git metadata (when run from CI) */
     git?: {
         branch: string;
@@ -33,6 +44,12 @@ export interface RunContext {
     };
     /** Grader model used for scoring */
     graderModel: string;
+    /** Platform/CI metadata for debugging flakes. */
+    host?: RunHost;
+    /** Free-form searchable tags — release IDs, regression hunts, experiments. */
+    labels?: string[];
+    /** Links to related runs (re-runs, comparison partners, API parent job). */
+    lineage?: RunLineage;
     /** Evaluation mode */
     mode: EvalMode;
     /** Models under evaluation */
@@ -40,6 +57,10 @@ export interface RunContext {
         id: string;
         label: string;
     }[];
+    /** Which team (and optionally individual) this run is attributable to. */
+    owner: RunOwner;
+    /** Human-authored "why I ran this" — useful for Content Lake archaeology. */
+    purpose?: string;
     /** Documentation source configuration */
     source: {
         baseUrl: string;
@@ -50,6 +71,8 @@ export interface RunContext {
     };
     /** Specific task IDs evaluated when scoped to a subset */
     taskIds?: string[];
+    /** Which AILF/Node ran the eval — for cross-version trend compatibility. */
+    tool?: RunTool;
     /** What initiated this run */
     trigger: RunTrigger;
 }

package/dist/adapters/api-client/build-request.d.ts

@@ -13,6 +13,16 @@
  * @see packages/eval/src/adapters/task-sources/repo-task-source.ts
  */
 import { type PipelineRequest } from "../../_vendor/ailf-core/index.d.ts";
+/**
+ * Thrown when `buildRemoteRequest` can't find any runnable tasks.
+ *
+ * The CLI catches this separately from ZodError so it can print the
+ * message without an accompanying stack trace — the message is already
+ * the whole story for the user.
+ */
+export declare class NoRunnableTasksError extends Error {
+    readonly name = "NoRunnableTasksError";
+}
 /** Options for building a remote pipeline request. */
 export interface BuildRequestOptions {
     /** Path to .ailf/tasks/ directory. */
@@ -27,6 +37,7 @@ export interface BuildRequestOptions {
  */
 export interface RemoteConfigSlice {
     mode?: string;
+    variant?: string;
     debug?: {
         enabled?: boolean;
         firstN?: number;
@@ -51,6 +62,18 @@ export interface RemoteConfigSlice {
     readinessEnabled?: boolean;
     discoveryReportEnabled?: boolean;
     noRemoteCache?: boolean;
+    /**
+     * D0037 / W0069 — CLI-flag overrides for the caller envelope. These
+     * take precedence over the equivalent env vars when set. When both a
+     * flag and its env var are unset the field is omitted from the
+     * request (server applies its own defaults).
+     */
+    classificationOption?: string;
+    ownerTeamOption?: string;
+    ownerIndividualOption?: string;
+    purposeOption?: string;
+    /** Repeatable --label values; appended to AILF_LABELS env values. */
+    labelOptions?: string[];
 }
 /**
  * Build a PipelineRequest from local tasks and config.
@@ -75,3 +98,22 @@ export declare function buildRemoteRequest(options: BuildRequestOptions): Promis
  * Returns the resolved path or throws if not found.
  */
 export declare function resolveTasksDir(rootDir: string, explicitPath?: string): string;
+/**
+ * Build the D0037 caller envelope payload from CLI flags + env vars.
+ *
+ * Precedence, highest first:
+ *   1. Explicit CLI flag (--classification, --owner-team, --purpose, …)
+ *   2. Env var (AILF_CLASSIFICATION, AILF_OWNER_TEAM, AILF_PURPOSE, …)
+ *   3. Omit — server applies its own defaults (ad-hoc / unknown).
+ *
+ * Labels are additive: --label values concatenate with AILF_LABELS.
+ *
+ * `executor` is always set on remote submissions because we know the
+ * invocation is a user-driven CLI call. Surface defaults to `"cli"`
+ * unless AILF_EXECUTOR_SURFACE explicitly overrides; name falls back to
+ * GITHUB_ACTOR when available.
+ *
+ * Returns partial `PipelineRequest` fields only. Omits any key whose
+ * source (flag + env) was unset.
+ */
+export declare function buildCallerEnvelope(config: RemoteConfigSlice): Partial<PipelineRequest>;

package/dist/adapters/api-client/build-request.js

@@ -15,8 +15,7 @@
 import { existsSync } from "fs";
 import { resolve } from "path";
 import { PipelineRequestSchema, } from "../../_vendor/ailf-core/index.js";
-import { LEGACY_EVAL_MODE_ALIASES } from "../../_vendor/ailf-shared/index.js";
-import { LiteracyVariant } from "../../pipeline/normalize-mode.js";
+import { LEGACY_EVAL_MODE_ALIASES, isRunClassification, } from "../../_vendor/ailf-shared/index.js";
 import { RepoTaskSource } from "../task-sources/repo-task-source.js";
 const LEGACY_LITERACY_VARIANT_SET = new Set(LEGACY_EVAL_MODE_ALIASES);
 /**
@@ -27,6 +26,16 @@ const LEGACY_LITERACY_VARIANT_SET = new Set(LEGACY_EVAL_MODE_ALIASES);
 function resolveCanonicalTaskMode(configMode) {
     return LEGACY_LITERACY_VARIANT_SET.has(configMode) ? "literacy" : configMode;
 }
+/**
+ * Thrown when `buildRemoteRequest` can't find any runnable tasks.
+ *
+ * The CLI catches this separately from ZodError so it can print the
+ * message without an accompanying stack trace — the message is already
+ * the whole story for the user.
+ */
+export class NoRunnableTasksError extends Error {
+    name = "NoRunnableTasksError";
+}
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
@@ -56,11 +65,13 @@ export async function buildRemoteRequest(options) {
         ? allTasks.filter((t) => t.mode === taskModeFilter)
         : allTasks;
     if (tasks.length === 0) {
-        throw new Error("No tasks found after applying filters.\n" +
-            `  Tasks directory: ${tasksDir}\n` +
-            (config.areas ? `  Area filter: ${config.areas.join(", ")}\n` : "") +
-            (config.tasks ? `  Task filter: ${config.tasks.join(", ")}\n` : "") +
-            "  Check that your .ailf/tasks/ YAML files define tasks matching these filters.");
+        throw await emptyTasksError({
+            taskSource,
+            tasksDir,
+            config,
+            filterOptions,
+            taskModeFilter,
+        });
     }
     // 2. Convert tasks to inline format
     const inlineTasks = tasks.map(taskToInlineFormat);
@@ -69,10 +80,14 @@ export async function buildRemoteRequest(options) {
         taskMode: "inline",
         inlineTasks,
     };
-    // Mode
-    if (config.mode && config.mode !== LiteracyVariant.FULL) {
+    // Mode + variant — send both when set so the server sees the caller's
+    // canonical intent. Legacy aliases ("full", "baseline", …) are accepted
+    // by `PipelineRequestSchema.mode` for back-compat but the CLI now emits
+    // the canonical form (`mode: "literacy"` + explicit `variant`).
+    if (config.mode)
         raw.mode = config.mode;
-    }
+    if (config.variant)
+        raw.variant = config.variant;
     // Debug
     if (config.debug?.enabled) {
         raw.debug = config.debug;
@@ -127,6 +142,10 @@ export async function buildRemoteRequest(options) {
     const callerGit = detectCallerGit();
     if (callerGit)
         raw.callerGit = callerGit;
+    // D0037 caller envelope — merge CLI flags + env vars and attach each
+    // populated field. Flags override env. Skipped fields are omitted so
+    // the server applies its own defaults.
+    Object.assign(raw, buildCallerEnvelope(config));
     // 4. Validate the assembled request
     const parsed = PipelineRequestSchema.parse(raw);
     return { request: parsed, taskCount: tasks.length };
@@ -202,6 +221,88 @@ function taskToInlineFormat(task) {
     }
     return inline;
 }
+/**
+ * Build a descriptive error when the task list is empty after filtering.
+ *
+ * Loads the full task list a second time with `includeDrafts: true` so we
+ * can distinguish the two common failure modes:
+ *
+ * 1. Every discovered task is non-active (`status: "draft"` from
+ *    `ailf init` scaffolding, or `status: "paused"`). Tell the user how
+ *    to opt a task in.
+ * 2. The tasks directory is genuinely empty for this filter combination.
+ *    Echo the filters back so the mismatch is obvious.
+ *
+ * The directory-missing and file-missing cases are already surfaced
+ * earlier by `RepoTaskSource.loadTasks()`, so we never reach this helper
+ * for those.
+ */
+async function emptyTasksError(args) {
+    const { taskSource, tasksDir, config, filterOptions, taskModeFilter } = args;
+    // Re-load without the status gate to categorize what got filtered.
+    let relaxed = [];
+    try {
+        relaxed = await taskSource.loadTasks({
+            ...(filterOptions ?? {}),
+            includeDrafts: true,
+        });
+    }
+    catch {
+        // Fall through to the generic message if re-loading fails for any
+        // reason (e.g. directory removed mid-run).
+    }
+    const modeMatched = taskModeFilter
+        ? relaxed.filter((t) => t.mode === taskModeFilter)
+        : relaxed;
+    const drafts = modeMatched.filter((t) => (t.status ?? "active") === "draft");
+    const paused = modeMatched.filter((t) => t.status === "paused");
+    const filtersBlock = (config.areas?.length
+        ? `  Area filter: ${config.areas.join(", ")}\n`
+        : "") +
+        (config.tasks?.length
+            ? `  Task filter: ${config.tasks.join(", ")}\n`
+            : "") +
+        (config.tags?.length ? `  Tag filter: ${config.tags.join(", ")}\n` : "") +
+        (taskModeFilter ? `  Mode filter: ${taskModeFilter}\n` : "");
+    if (modeMatched.length === 0) {
+        return new NoRunnableTasksError("No tasks matched your filters.\n" +
+            `  Tasks directory: ${tasksDir}\n` +
+            filtersBlock +
+            "  Check that your .ailf/tasks/ YAML or .task.ts files define tasks\n" +
+            "  matching these filters.");
+    }
+    // All matched tasks were excluded by the status gate.
+    const draftIds = drafts.map((t) => t.id);
+    const pausedIds = paused.map((t) => t.id);
+    const draftSample = draftIds.slice(0, 3).join(", ");
+    const draftMore = draftIds.length > 3 ? `, +${draftIds.length - 3} more` : "";
+    const pausedSample = pausedIds.slice(0, 3).join(", ");
+    const pausedMore = pausedIds.length > 3 ? `, +${pausedIds.length - 3} more` : "";
+    const lines = [];
+    lines.push("No runnable tasks after applying filters.");
+    lines.push(`  Tasks directory: ${tasksDir}`);
+    if (filtersBlock)
+        lines.push(filtersBlock.trimEnd());
+    if (drafts.length > 0) {
+        lines.push(`  ${drafts.length} task(s) skipped because status: "draft": ${draftSample}${draftMore}`);
+    }
+    if (paused.length > 0) {
+        lines.push(`  ${paused.length} task(s) skipped because status: "paused": ${pausedSample}${pausedMore}`);
+    }
+    lines.push("");
+    lines.push("  To run one of these anyway, either:");
+    if (drafts.length > 0) {
+        lines.push(`    • Change the task's status field from "draft" to "active", or`);
+        lines.push(`    • Target it explicitly: --task ${drafts[0]?.id ?? "<id>"}`);
+    }
+    else if (paused.length > 0) {
+        lines.push(`    • Target it explicitly by id: --task ${paused[0]?.id ?? "<id>"}, or`);
+        lines.push(`    • Flip its status from "paused" to "active"`);
+    }
+    lines.push("  Tasks scaffolded by `ailf init` ship as drafts so you can edit");
+    lines.push("  them before they start contributing to your literacy score.");
+    return new NoRunnableTasksError(lines.join("\n"));
+}
 function buildFilterOptions(config) {
     const areas = config.areas?.length ? config.areas : undefined;
     const taskIds = config.tasks?.length ? config.tasks : undefined;
@@ -210,6 +311,83 @@ function buildFilterOptions(config) {
         return undefined;
     return { areas, taskIds, tags };
 }
+/**
+ * Build the D0037 caller envelope payload from CLI flags + env vars.
+ *
+ * Precedence, highest first:
+ *   1. Explicit CLI flag (--classification, --owner-team, --purpose, …)
+ *   2. Env var (AILF_CLASSIFICATION, AILF_OWNER_TEAM, AILF_PURPOSE, …)
+ *   3. Omit — server applies its own defaults (ad-hoc / unknown).
+ *
+ * Labels are additive: --label values concatenate with AILF_LABELS.
+ *
+ * `executor` is always set on remote submissions because we know the
+ * invocation is a user-driven CLI call. Surface defaults to `"cli"`
+ * unless AILF_EXECUTOR_SURFACE explicitly overrides; name falls back to
+ * GITHUB_ACTOR when available.
+ *
+ * Returns partial `PipelineRequest` fields only. Omits any key whose
+ * source (flag + env) was unset.
+ */
+export function buildCallerEnvelope(config) {
+    const out = {};
+    // Classification: flag > env. Validated against the closed enum.
+    const rawClassification = config.classificationOption ??
+        process.env.AILF_CLASSIFICATION?.trim() ??
+        undefined;
+    if (rawClassification) {
+        if (isRunClassification(rawClassification)) {
+            out.classification = rawClassification;
+        }
+        else {
+            // Surface the invalid value so downstream Zod validation gives a
+            // clear error message pointing at the flag, not the inner enum.
+            out.classification =
+                rawClassification;
+        }
+    }
+    // Owner: flag > env. Team required, individual optional.
+    const team = config.ownerTeamOption ?? process.env.AILF_OWNER_TEAM?.trim() ?? undefined;
+    const individual = config.ownerIndividualOption ??
+        process.env.AILF_OWNER_INDIVIDUAL?.trim() ??
+        process.env.GITHUB_ACTOR?.trim() ??
+        undefined;
+    if (team) {
+        out.owner = individual ? { team, individual } : { team };
+    }
+    // Purpose: flag > env.
+    const purpose = config.purposeOption ?? process.env.AILF_PURPOSE?.trim() ?? undefined;
+    if (purpose)
+        out.purpose = purpose;
+    // Labels: flag AND env are additive (dedup + trim).
+    const flagLabels = config.labelOptions ?? [];
+    const envLabels = (process.env.AILF_LABELS ?? "")
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean);
+    const mergedLabels = Array.from(new Set([...envLabels, ...flagLabels]));
+    if (mergedLabels.length > 0)
+        out.labels = mergedLabels;
+    // Executor: always set on remote submissions — we know this is a CLI
+    // user. Only omit when absolutely nothing identifying is available.
+    const surfaceEnv = process.env.AILF_EXECUTOR_SURFACE?.trim();
+    const surface = surfaceEnv === "studio" || surfaceEnv === "api" ? surfaceEnv : "cli";
+    const githubActor = process.env.GITHUB_ACTOR?.trim() || undefined;
+    const nameFromIndividual = config.ownerIndividualOption ??
+        process.env.AILF_OWNER_INDIVIDUAL?.trim() ??
+        undefined;
+    const executorName = githubActor ?? nameFromIndividual;
+    const executor = {
+        type: "user",
+        surface,
+    };
+    if (executorName)
+        executor.name = executorName;
+    if (githubActor)
+        executor.githubActor = githubActor;
+    out.executor = executor;
+    return out;
+}
 /**
  * Auto-detect caller git metadata from GitHub Actions environment variables.
  *

package/dist/adapters/api-client/index.d.ts

@@ -5,7 +5,7 @@
  *   import { ApiClient, buildRemoteRequest, resolveTasksDir } from "./adapters/api-client/index.js"
  */
 export { ApiClient } from "./api-client.js";
-export { buildRemoteRequest, resolveTasksDir, type BuildRequestOptions, type RemoteConfigSlice, } from "./build-request.js";
+export { buildCallerEnvelope, buildRemoteRequest, NoRunnableTasksError, resolveTasksDir, type BuildRequestOptions, type RemoteConfigSlice, } from "./build-request.js";
 export { ApiAuthError, ApiConnectionError, ApiError, ApiTimeoutError, } from "./errors.js";
 export { formatJobError } from "./format-error.js";
 export { createProgressDisplay } from "./progress.js";

package/dist/adapters/api-client/index.js

@@ -5,7 +5,7 @@
  *   import { ApiClient, buildRemoteRequest, resolveTasksDir } from "./adapters/api-client/index.js"
  */
 export { ApiClient } from "./api-client.js";
-export { buildRemoteRequest, resolveTasksDir, } from "./build-request.js";
+export { buildCallerEnvelope, buildRemoteRequest, NoRunnableTasksError, resolveTasksDir, } from "./build-request.js";
 export { ApiAuthError, ApiConnectionError, ApiError, ApiTimeoutError, } from "./errors.js";
 export { formatJobError } from "./format-error.js";
 export { createProgressDisplay } from "./progress.js";

package/dist/commands/explain-handler.js

@@ -727,6 +727,11 @@ async function buildPipelineExplainPlan(actionCommand, rootDir) {
         artifactsDir: raw.artifactsDir,
         artifactsDryRun: raw.artifactsDryRun ?? false,
         artifactsExclude: raw.artifactsExclude,
+        classification: raw.classification,
+        ownerTeam: raw.ownerTeam,
+        ownerIndividual: raw.ownerIndividual,
+        purpose: raw.purpose,
+        label: raw.label ?? [],
     };
     const resolved = computeResolvedOptions(withDefaults);
     const planOpts = {

package/dist/commands/pipeline-action.d.ts

@@ -68,6 +68,12 @@ export interface ResolvedOptions {
     artifactsDir?: string;
     artifactsDryRun: boolean;
     artifactsExclude?: readonly string[];
+    /** D0037 / W0069 caller envelope — surfaces only on --remote today. */
+    classificationOption?: string;
+    ownerTeamOption?: string;
+    ownerIndividualOption?: string;
+    purposeOption?: string;
+    labelOptions: string[];
 }
 /**
  * Pure option resolution — computes ResolvedOptions from CLI flags without

package/dist/commands/pipeline-action.js

@@ -14,7 +14,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { dirname, resolve } from "path";
 import { fileURLToPath } from "url";
 import { classifyUrls } from "../pipeline/classify-url.js";
-import { normalizeMode } from "../pipeline/normalize-mode.js";
+import { LiteracyVariant, normalizeMode } from "../pipeline/normalize-mode.js";
 import { assessImpact, buildReverseMapping, } from "../pipeline/reverse-mapping.js";
 import { buildAppContext, parseArtifactUploadEnv, } from "../orchestration/build-app-context.js";
 import { buildStepSequence } from "../orchestration/build-step-sequence.js";
@@ -47,6 +47,13 @@ export function computeResolvedOptions(opts) {
         mode = normalized.mode;
         // Explicit --variant flag takes precedence over what normalizeMode inferred
         variant = opts.variant ?? normalized.variant;
+        // Canonical mode "literacy" with no variant defaults to the full variant
+        // (standard + agentic). This preserves the pre-canonical CLI behavior
+        // where `--mode full` was the default, without emitting the legacy alias
+        // deprecation warning for users who pass no flags at all.
+        if (mode === "literacy" && !variant) {
+            variant = LiteracyVariant.FULL;
+        }
     }
     catch (err) {
         console.error(`❌ ${err instanceof Error ? err.message : String(err)}`);
@@ -269,6 +276,11 @@ export function computeResolvedOptions(opts) {
         artifactsDir: resolveArtifactsDir(opts),
         artifactsDryRun: opts.artifactsDryRun,
         artifactsExclude: parseArtifactsExcludeList(opts.artifactsExclude),
+        classificationOption: opts.classification?.trim() || undefined,
+        ownerTeamOption: opts.ownerTeam?.trim() || undefined,
+        ownerIndividualOption: opts.ownerIndividual?.trim() || undefined,
+        purposeOption: opts.purpose?.trim() || undefined,
+        labelOptions: opts.label ?? [],
     };
 }
 /**

package/dist/commands/pipeline.d.ts

@@ -68,5 +68,10 @@ export interface PipelineCliOptions {
     artifactsDir?: string;
     artifactsDryRun: boolean;
     artifactsExclude?: string;
+    classification?: string;
+    ownerTeam?: string;
+    ownerIndividual?: string;
+    purpose?: string;
+    label: string[];
 }
 export declare function createPipelineCommand(): Command;