@ttctl/core 0.1.0-rc.6 → 0.1.0-rc.8

package/dist/services/applications/index.js

@@ -1,7 +1,9 @@
 // SPDX-License-Identifier: AGPL-3.0-only
 // Copyright (C) 2026 Oleksii PELYKH
+import { JobExpertiseAnswerInputSchema, JobPositionAnswerInputSchema, PitchInputSchema, } from "../../__generated__/zod-schemas.js";
 import { buildDryRunPreview } from "../../transport.js";
 import { callGatewayShared } from "../_shared/transport.js";
+export { JobExpertiseAnswerInputSchema, JobPositionAnswerInputSchema, PitchInputSchema };
 export class ApplicationsError extends Error {
     code;
     name = "ApplicationsError";
@@ -318,16 +320,20 @@ export async function list(token, opts = {}) {
  * Throws `ApplicationsError("NOT_FOUND")` for two distinct wire shapes
  * — both meaning "id doesn't resolve to a viewable item":
  *
- * 1. **Top-level GraphQL error `Record not found`** (the empirical
- *    happy-sad path — verified live on 2026-05-10). The gateway
- *    short-circuits with a top-level `errors[]` carrying the literal
- *    message "Record not found" rather than returning `data: null`.
- *    `callGateway` raises `GRAPHQL_ERROR`; we catch and translate.
+ * 1. **Top-level GraphQL error matched by {@link NOT_FOUND_MESSAGE_PATTERN}**
+ *    — the shared regex covers `Record not found` (the empirical
+ *    happy-sad path on `JobActivityItem(id:)`, verified live on
+ *    2026-05-10), `Invalid ID` (jobs-service precedent), and
+ *    `Node id ... resolves to ...` (the Relay decode error per
+ *    `project-toptal-wire-quirks` memory; load-bearing for the
+ *    pre-apply read suite added in #424 where `viewer.job(id:)`
+ *    bad-ids surface as Relay decode errors). `callGateway` raises
+ *    `GRAPHQL_ERROR`; we catch and translate.
  * 2. **Successful response with `viewer.jobActivityItem === null`** —
  *    not observed in practice but kept as defensive coverage in case
  *    the gateway ever switches to the data-shape sentinel.
  */
-const NOT_FOUND_MESSAGE_PATTERN = /Record not found/i;
+const NOT_FOUND_MESSAGE_PATTERN = /Record not found|Invalid ID|Node id .*? resolves to/i;
 export async function show(token, id) {
     let data;
     try {
@@ -390,6 +396,382 @@ export async function stats(token) {
     return { total, groups: groupResults };
 }
 // ---------------------------------------------------------------------
+// Trimmed inline query strings for the three pre-apply read ops
+// (#424). Operation NAMES are kept verbatim from the captured wire
+// (`JobApplyData`, `JobApplicationQuestions`,
+// `JobApplicationRateInsight`) — any future server-side allowlisting
+// that gates on operation name continues to recognize them.
+//
+// Schema gaps acknowledged:
+//   - `TalentJob.operations { apply { errors } }` — `JobOperationsApply.errors`
+//     types are in the schema (`JobOperationsApplyError { code, message }`),
+//     but the OP shape itself is captured-only; the captured-op
+//     selection is the wire authority.
+//   - `TalentJob.expertiseQuestions` — not present in the synthesized
+//     schema at all; selection mirrors the captured-op shape verbatim
+//     (`{ id subject { ... on Industry / Skill } }`).
+//   - `TalentJob.rateInsight(onlyHourlyRates, requestedRate)` — also
+//     not in the synthesized schema with that argument signature; the
+//     captured op passes both args, schema declares the field with no
+//     args (same pattern as `jobActivityList`).
+//   - Un-aliased union-member fields on `TalentJobRateInsight`: the
+//     captured `JobApplicationRateInsight.graphql` aliases
+//     `competitiveRevenue: estimatedRevenue` /
+//     `uncompetitiveRevenue: estimatedRevenue` (Apollo client-side
+//     normalization hint to avoid same-name-different-meaning
+//     collisions on the cache side). The inline query below selects
+//     them BARE — spec-conformant per GraphQL FieldsInSetCanMerge
+//     since both wire members carry `BigDecimal estimatedRevenue` /
+//     `BigDecimal estimatedRevenueExplanation` (same scalar type, so
+//     same-name selection across union members merges cleanly).
+//     {@link projectRateInsight} consumes the un-aliased response
+//     keys. If the server ever rejects un-aliased selections, #445
+//     E2E catches it on the live wire (this is a Track 1 op).
+// ---------------------------------------------------------------------
+const JOB_APPLY_DATA_QUERY = `query JobApplyData($jobId: ID!) {
+  viewer {
+    __typename
+    id
+    viewerRole {
+      __typename
+      rates { __typename hourly }
+    }
+    job(id: $jobId) {
+      __typename
+      id
+      isCoaching
+      hasRequiredApplicationPitch
+      operations {
+        __typename
+        apply {
+          __typename
+          errors { __typename code message }
+        }
+      }
+    }
+  }
+  platformConfiguration {
+    __typename
+    id
+    rateValidationRules {
+      __typename
+      hourly { __typename minRate rateStep }
+    }
+  }
+}`;
+const JOB_APPLICATION_QUESTIONS_QUERY = `query JobApplicationQuestions($jobId: ID!) {
+  viewer {
+    __typename
+    id
+    job(id: $jobId) {
+      __typename
+      id
+      questions(hideExpertiseQuestion: true) {
+        __typename
+        id
+        question
+        isRequired
+      }
+      expertiseQuestions {
+        __typename
+        id
+        subject {
+          __typename
+          ... on Industry { __typename id name }
+          ... on Skill { __typename id name }
+        }
+      }
+    }
+  }
+}`;
+// `$requestedRate: BigDecimal` is kept in the operation signature to
+// stay verbatim-faithful to the captured wire (per the
+// schema/contract rule's "live API is the authority" principle).
+// The public {@link rateInsight} signature does NOT expose
+// `requestedRate` per #424 AC; the variable is always threaded as
+// `null`, which the wire treats equivalently to "show me the insight
+// for my default rate". Re-exposing the parameter is a future-issue
+// widening — surface stays additive.
+const JOB_APPLICATION_RATE_INSIGHT_QUERY = `query JobApplicationRateInsight($jobId: ID!, $requestedRate: BigDecimal) {
+  viewer {
+    __typename
+    id
+    job(id: $jobId) {
+      __typename
+      id
+      hourlyRateInsights: rateInsight(onlyHourlyRates: true, requestedRate: $requestedRate) {
+        __typename
+        ... on TalentJobRateInsightCompetitive {
+          __typename
+          estimatedRevenue
+          estimatedRevenueExplanation
+          longTermDisclaimer
+        }
+        ... on TalentJobRateInsightUncompetitive {
+          __typename
+          estimatedRevenue
+          estimatedRevenueExplanation
+          recentApplicationRate
+          recommendedRate
+        }
+      }
+    }
+  }
+}`;
+/**
+ * Project `viewer.job.operations.apply.errors` from the captured wire
+ * shape into the public {@link ApplyError}[] form. Filters list-entry
+ * nulls defensively (the schema declares
+ * `JobOperationsApply.errors: [JobOperationsApplyError]!` — non-null
+ * LIST but nullable ENTRIES); the resulting list always carries
+ * non-null entries.
+ */
+function projectApplyErrors(errors) {
+    if (errors == null)
+        return [];
+    return errors.filter((e) => e !== null).map((e) => ({ code: e.code, message: e.message }));
+}
+function projectMatcherQuestion(wire) {
+    return {
+        identifier: wire.id,
+        prompt: wire.question,
+        type: "matcher",
+        isMandatory: wire.isRequired ?? false,
+    };
+}
+function projectExpertiseQuestion(wire) {
+    // `subject.name` is selected on both `Industry` and `Skill` inline
+    // fragments in the captured op; defensive `?? ""` covers a
+    // wire-shape regression where neither inline fragment matched (the
+    // server returned an as-yet-unknown subject variant). #445 live
+    // E2E is the wire authority on what subject variants exist.
+    const prompt = wire.subject?.name ?? "";
+    return {
+        identifier: wire.id,
+        prompt,
+        type: "expertise",
+        // The captured `JobApplicationQuestions` operation selects no
+        // `isRequired` on `expertiseQuestions` — projected as `true`
+        // here because the apply flow requires expertise answers. See
+        // {@link ApplicationQuestion.isMandatory} JSDoc for the
+        // grounded inference + the #445 wire-authority follow-up.
+        isMandatory: true,
+    };
+}
+function projectRateInsight(wire) {
+    if (wire.__typename === "TalentJobRateInsightCompetitive") {
+        return {
+            kind: "competitive",
+            estimatedRevenue: wire.estimatedRevenue,
+            estimatedRevenueExplanation: wire.estimatedRevenueExplanation,
+            longTermDisclaimer: wire.longTermDisclaimer,
+        };
+    }
+    // Capture the discriminant through a widened `string` local so the
+    // runtime defense below survives ESLint's `no-unnecessary-condition`
+    // rule — without the widening, the narrower would prove the
+    // !== arm dead (TS exhausts the closed union to
+    // `TalentJobRateInsightUncompetitive` after the early return above).
+    // At RUNTIME, this op is in `GATEWAY_MOBILE_KNOWN_UNTRUSTED_OPS` and
+    // the wire may carry a `__typename` outside the closed type union
+    // (future server-side union extension lands here even though the
+    // type system thinks it's unreachable). Mirrors the
+    // {@link kindFromMetadataTypename} pattern below (L1939+):
+    // unknown typename → typed `WIRE_SHAPE_ERROR` with the offending
+    // value echoed, instead of silently mislabelling as `uncompetitive`
+    // with `undefined` `recentApplicationRate` / `recommendedRate`.
+    const typename = wire.__typename;
+    if (typename !== "TalentJobRateInsightUncompetitive") {
+        throw new ApplicationsError("WIRE_SHAPE_ERROR", `Unknown rate insight variant: "${typename}".`);
+    }
+    return {
+        kind: "uncompetitive",
+        estimatedRevenue: wire.estimatedRevenue,
+        estimatedRevenueExplanation: wire.estimatedRevenueExplanation,
+        recentApplicationRate: wire.recentApplicationRate,
+        recommendedRate: wire.recommendedRate,
+    };
+}
+/**
+ * Pre-apply aggregate context for a job (#424). Wraps `JobApplyData
+ * ($jobId)` — the mobile gateway's aggregate pre-apply query — and
+ * trims the response to the load-bearing scalars (REQ-A4 rate
+ * default, apply-state errors, platform validation bounds, plus
+ * basic job context). The captured operation also pulls in the
+ * pitch / talent-card / market-condition cascades; those are
+ * deliberately elided here. The apply path (#426) takes the pitch
+ * from `--pitch-file` per ADR-008's grammar, NOT from
+ * `suggestedPitch` / `lastPitches`, and `applyQuestions` /
+ * `rateInsight` cover the other captured slices. Future widening is
+ * additive.
+ *
+ * **Wire authority**: hand-authored from the captured
+ * `JobApplyData.graphql` selection set; CLAUDE.md schema/contract
+ * rule TRIGGERED for #424, live E2E coverage in #445.
+ *
+ * **Bad-id behavior**: `viewer.job(id:)` returns the Relay decode
+ * error (per `project-toptal-wire-quirks` memory) when the supplied
+ * id doesn't resolve to a viewable job; remapped to
+ * `ApplicationsError("NOT_FOUND")` via the shared
+ * {@link NOT_FOUND_MESSAGE_PATTERN} (widened in #424).
+ *
+ * @throws `ApplicationsError("NOT_FOUND")` when the job id doesn't
+ *   resolve (Relay decode error, `Invalid ID`, `Record not found`,
+ *   or successful response with `viewer.job === null`).
+ * @throws `ApplicationsError("NO_VIEWER")` when the session is valid
+ *   but no viewer is bound (defensive — `callGateway` with
+ *   `requireViewer: true` already raises this case, but the
+ *   post-call null check keeps the type narrowing clean).
+ */
+export async function applyData(token, jobId) {
+    let data;
+    try {
+        data = await callGateway(token, "JobApplyData", JOB_APPLY_DATA_QUERY, {
+            jobId,
+        });
+    }
+    catch (err) {
+        if (err instanceof ApplicationsError &&
+            err.code === "GRAPHQL_ERROR" &&
+            NOT_FOUND_MESSAGE_PATTERN.test(err.message)) {
+            throw new ApplicationsError("NOT_FOUND", `No job found with id "${jobId}" (or you don't have access to it).`, {
+                cause: err,
+            });
+        }
+        throw err;
+    }
+    if (data.viewer === null) {
+        throw new ApplicationsError("NO_VIEWER", "Session is valid but no viewer is bound to it.");
+    }
+    if (data.viewer.job === null) {
+        throw new ApplicationsError("NOT_FOUND", `No job found with id "${jobId}" (or you don't have access to it).`);
+    }
+    const jobWire = data.viewer.job;
+    const applyErrors = projectApplyErrors(jobWire.operations.apply.errors);
+    const suggestedRate = data.viewer.viewerRole?.rates.hourly ?? null;
+    const rateValidationWire = data.platformConfiguration?.rateValidationRules?.hourly ?? null;
+    const rateValidation = rateValidationWire === null ? null : { minRate: rateValidationWire.minRate, rateStep: rateValidationWire.rateStep };
+    return {
+        job: {
+            id: jobWire.id,
+            isCoaching: jobWire.isCoaching,
+            hasRequiredApplicationPitch: jobWire.hasRequiredApplicationPitch,
+        },
+        applyErrors,
+        canApply: applyErrors.length === 0,
+        suggestedRate,
+        rateValidation,
+    };
+}
+/**
+ * Pre-apply matcher + expertise questions inventory for a job (#424).
+ * Wraps `JobApplicationQuestions($jobId)`; trims the captured
+ * operation's `subject.possibleAnswers` cascades — the four-field
+ * {@link ApplicationQuestion} shape is the public projection per
+ * #424 AC.
+ *
+ * The two arrays surface verbatim presence: empty when the job has
+ * no questions of that kind. Order is server-supplied; no
+ * client-side re-sorting.
+ *
+ * **Bad-id behavior + NOT_FOUND mapping**: identical to
+ * {@link applyData}.
+ *
+ * @throws `ApplicationsError("NOT_FOUND")` for unresolved job ids.
+ * @throws `ApplicationsError("NO_VIEWER")` for sessions with no
+ *   bound viewer.
+ */
+export async function applyQuestions(token, jobId) {
+    let data;
+    try {
+        data = await callGateway(token, "JobApplicationQuestions", JOB_APPLICATION_QUESTIONS_QUERY, { jobId });
+    }
+    catch (err) {
+        if (err instanceof ApplicationsError &&
+            err.code === "GRAPHQL_ERROR" &&
+            NOT_FOUND_MESSAGE_PATTERN.test(err.message)) {
+            throw new ApplicationsError("NOT_FOUND", `No job found with id "${jobId}" (or you don't have access to it).`, {
+                cause: err,
+            });
+        }
+        throw err;
+    }
+    if (data.viewer === null) {
+        throw new ApplicationsError("NO_VIEWER", "Session is valid but no viewer is bound to it.");
+    }
+    if (data.viewer.job === null) {
+        throw new ApplicationsError("NOT_FOUND", `No job found with id "${jobId}" (or you don't have access to it).`);
+    }
+    const jobWire = data.viewer.job;
+    const matcherWire = jobWire.questions ?? [];
+    const expertiseWire = jobWire.expertiseQuestions ?? [];
+    return {
+        matcherQuestions: matcherWire.filter((q) => q !== null).map(projectMatcherQuestion),
+        expertiseQuestions: expertiseWire
+            .filter((q) => q !== null)
+            .map(projectExpertiseQuestion),
+    };
+}
+/**
+ * Pre-apply rate guidance for a job (#424). Wraps
+ * `JobApplicationRateInsight($jobId)`; surfaces the captured
+ * operation's `TalentJobRateInsight` discriminated union as
+ * {@link RateInsight}. Returns `null` when the gateway omits the
+ * insight payload (the `rateInsight` field on the job resolves to
+ * null).
+ *
+ * The operation declares `$requestedRate: BigDecimal` (verbatim from
+ * the captured wire) but the public signature does NOT expose
+ * `requestedRate` per #424 AC — the variable is threaded as `null`,
+ * which the gateway treats as "show me the insight for the talent's
+ * default rate". Re-exposing the parameter is a future widening.
+ *
+ * **Wire shape**: union members carry `BigDecimal` scalar fields
+ * (`estimatedRevenue`, `recommendedRate`, `recentApplicationRate`)
+ * — NOT `Money { decimal verbose }` objects. The captured
+ * `JobApplicationRateInsight.graphql` operation selects them bare
+ * (no sub-selection), and the synthesized schema confirms
+ * `BigDecimal`. The #424 issue parenthetical "Money shape `{ decimal,
+ * verbose }` + range guidance" reflects an intuition rather than the
+ * captured wire; the captured operation's selection set is
+ * authoritative per the issue's own primary directive ("define shape
+ * based on captured operation's selection set"). PR body documents
+ * the deviation.
+ *
+ * **Bad-id behavior + NOT_FOUND mapping**: identical to
+ * {@link applyData}.
+ *
+ * @throws `ApplicationsError("NOT_FOUND")` for unresolved job ids.
+ * @throws `ApplicationsError("NO_VIEWER")` for sessions with no
+ *   bound viewer.
+ */
+export async function rateInsight(token, jobId) {
+    let data;
+    try {
+        data = await callGateway(token, "JobApplicationRateInsight", JOB_APPLICATION_RATE_INSIGHT_QUERY, { jobId, requestedRate: null });
+    }
+    catch (err) {
+        if (err instanceof ApplicationsError &&
+            err.code === "GRAPHQL_ERROR" &&
+            NOT_FOUND_MESSAGE_PATTERN.test(err.message)) {
+            throw new ApplicationsError("NOT_FOUND", `No job found with id "${jobId}" (or you don't have access to it).`, {
+                cause: err,
+            });
+        }
+        throw err;
+    }
+    if (data.viewer === null) {
+        throw new ApplicationsError("NO_VIEWER", "Session is valid but no viewer is bound to it.");
+    }
+    if (data.viewer.job === null) {
+        throw new ApplicationsError("NOT_FOUND", `No job found with id "${jobId}" (or you don't have access to it).`);
+    }
+    const insightWire = data.viewer.job.hourlyRateInsights;
+    if (insightWire === null)
+        return null;
+    return projectRateInsight(insightWire);
+}
+// ---------------------------------------------------------------------
 // Interest Request write-side ops (#411) — `confirm` / `reject` /
 // `rejectReasons`. All three are HAND-AUTHORED inline strings, NOT
 // codegen-driven:
@@ -751,4 +1133,900 @@ export async function rejectReasons(token) {
         flexible: reasons.flexible ?? [],
     };
 }
+const JOB_APPLY_MUTATION = `mutation JobApply($id: ID!, $comment: String, $matcherQuestionsAnswers: [JobPositionAnswerInput!], $expertiseQuestionsAnswers: [JobExpertiseAnswerInput!], $consentIssued: Boolean!, $requestedHourlyRate: BigDecimal!, $talentCard: PitchInput) {
+  job(id: $id) {
+    __typename
+    apply(input: {
+      comment: $comment
+      matcherQuestionsAnswers: $matcherQuestionsAnswers
+      expertiseQuestionsAnswers: $expertiseQuestionsAnswers
+      understand: $consentIssued
+      requestedHourlyRate: $requestedHourlyRate
+      pitchData: $talentCard
+    }) {
+      __typename
+      success
+      errors { __typename code key message }
+      job {
+        __typename
+        id
+        activityItem {
+          __typename
+          id
+          statusV2 { __typename value verbose }
+          jobApplication {
+            __typename
+            id
+            requestedHourlyRate { __typename decimal }
+          }
+        }
+      }
+    }
+  }
+}`;
+function projectJobApplicationRecord(activityItem) {
+    if (activityItem.jobApplication === null) {
+        throw new ApplicationsError("UNKNOWN", "JobApply returned success but activityItem.jobApplication was null.");
+    }
+    return {
+        id: activityItem.jobApplication.id,
+        statusV2: activityItem.statusV2,
+        requestedHourlyRate: activityItem.jobApplication.requestedHourlyRate,
+        jobActivityItemId: activityItem.id,
+    };
+}
+/**
+ * Structural validation: every entry in `answers[]` must carry a
+ * string id at `idField` matching one of `validIds`. Rejects unknown
+ * ids with `WIRE_SHAPE_ERROR` carrying the offending array path
+ * (e.g. `matcherAnswers[2]`) so callers can fix the input.
+ *
+ * `idField` is parameterized because the recovered SDL uses
+ * **asymmetric field names** across the two answer types — matcher
+ * answers (`JobPositionAnswerInput`) carry the id at `id`, while
+ * expertise answers (`JobExpertiseAnswerInput`) carry it at
+ * `questionId`. See #438 § Stage-2 tightening (the recovered shapes
+ * are committed in `packages/core/src/__generated__/zod-schemas.ts`
+ * and treated as the canonical wire-contract authority).
+ */
+function validateAnswerIds(answers, validIds, path, idField) {
+    if (answers === undefined)
+        return;
+    for (let i = 0; i < answers.length; i++) {
+        const entry = answers[i];
+        if (typeof entry !== "object" || entry === null) {
+            throw new ApplicationsError("WIRE_SHAPE_ERROR", `${path}[${i}]: not an object — expected { ${idField}, answer, ... }.`);
+        }
+        const qid = entry[idField];
+        if (typeof qid !== "string") {
+            throw new ApplicationsError("WIRE_SHAPE_ERROR", `${path}[${i}]: missing or non-string "${idField}" property.`);
+        }
+        if (!validIds.has(qid)) {
+            throw new ApplicationsError("WIRE_SHAPE_ERROR", `${path}[${i}]: ${idField} "${qid}" does not match any question returned from applyQuestions().`);
+        }
+    }
+}
+/**
+ * Direct-apply to a Toptal job — wire `JobApply` (#426, ADR-008
+ * § Decision Part 5).
+ *
+ * Flow:
+ *
+ *   1. **Consent gate**: refuses the call (`CONSENT_REQUIRED`) BEFORE
+ *      any wire call when `input.consentIssued !== true`. Type-system
+ *      gate at `ApplyInput.consentIssued: true` covers compile-time;
+ *      the runtime check covers `as`-cast bypasses and JSON-sourced
+ *      inputs.
+ *   2. **Dry-run short-circuit**: when `options.dryRun === true`,
+ *      emits a {@link DryRunPreview} with the prepared variables
+ *      (including `<resolved at apply time>` placeholders for fields
+ *      that would have been resolved by the pre-fetch) and returns
+ *      `{ kind: "preview", preview }`. Zero wire calls under dry-run —
+ *      including the 3 pre-fetch calls.
+ *   3. **Pre-fetch via Promise.all**: runs `applyData` +
+ *      `applyQuestions` + `rateInsight` concurrently. Promise.all
+ *      rejects-on-first; any pre-fetch failure (NOT_FOUND,
+ *      GRAPHQL_ERROR, AuthRevokedError) blocks the apply.
+ *   4. **Answer validation**: every `matcherAnswers[]` /
+ *      `expertiseAnswers[]` entry's `questionId` must resolve against
+ *      the inventory; unknown ids throw `WIRE_SHAPE_ERROR` with the
+ *      offending array path.
+ *   5. **Rate default**: when `input.requestedHourlyRate` is omitted,
+ *      threads `PreApplyData.suggestedRate` (the talent's own
+ *      configured rate). Throws `MUTATION_ERROR` if neither source
+ *      yields a rate.
+ *   6. **Wire call**: issues `JobApply` against the mobile gateway.
+ *   7. **Error mapping**: a `MutationResult.errors[]` entry with
+ *      `key === "already_applied"` is mapped to `ALREADY_APPLIED`
+ *      with a hint pointing at `ttctl applications show
+ *      <activity-id>`. Other `success: false` responses surface as
+ *      `MUTATION_ERROR` with the formatted error detail.
+ *
+ * **Bad-id behavior**: mutations crash 500 on bad ids per
+ * `project-toptal-wire-quirks` auto-memory. The service does NOT
+ * pre-validate the job id; the pre-fetch suite (`applyData` etc.)
+ * already surfaces NOT_FOUND via the shared widened
+ * {@link NOT_FOUND_MESSAGE_PATTERN} when the bad id is detected
+ * read-side.
+ */
+export async function apply(token, jobId, input, options = {}) {
+    // Consent gate — runtime check covers `as`-cast bypasses and
+    // JSON-sourced inputs from CLI/MCP. Fires BEFORE any wire call (no
+    // pre-fetch under refusal either — the dry-run path below still
+    // honors the consent gate so a probe with `consentIssued: false`
+    // does not emit a preview for a call that would have been refused).
+    //
+    // The widening cast (`as { consentIssued: unknown }`) is load-bearing:
+    // the static type `consentIssued: true` (literal) narrows the value
+    // to compile-time-true, which makes `!== true` look like dead code to
+    // the linter. The runtime check exists for the bypass paths the type
+    // system can't reach (CLI / MCP / agents passing JSON), where the
+    // value may genuinely be `undefined` or `false`.
+    if (input.consentIssued !== true) {
+        throw new ApplicationsError("CONSENT_REQUIRED", "Apply requires explicit consent: `consentIssued: true` is mandatory before any wire call.");
+    }
+    if (options.dryRun === true) {
+        // Skip the pre-fetch entirely (zero transport calls under dry-run)
+        // and emit a preview with placeholders for fields that would have
+        // been resolved live. Matches the
+        // `applications.confirm()` skipped-prefetch pattern.
+        const previewVariables = {
+            id: jobId,
+            comment: input.message ?? null,
+            matcherQuestionsAnswers: input.matcherAnswers ?? null,
+            expertiseQuestionsAnswers: input.expertiseAnswers ?? null,
+            consentIssued: true,
+            requestedHourlyRate: input.requestedHourlyRate ?? "<resolved at apply time>",
+            talentCard: input.pitchData ?? null,
+        };
+        return {
+            kind: "preview",
+            preview: buildDryRunPreview({
+                surface: "mobile-gateway",
+                authToken: token,
+                body: {
+                    operationName: "JobApply",
+                    query: JOB_APPLY_MUTATION,
+                    variables: previewVariables,
+                },
+            }),
+        };
+    }
+    // Pre-fetch via Promise.all — applyData + applyQuestions + rateInsight
+    // run concurrently. Promise.all rejects-on-first; intentional —
+    // any failure (NOT_FOUND, AuthRevokedError, GRAPHQL_ERROR) should
+    // block the mutation.
+    //
+    // The third return (rateInsight) is currently UNUSED by the apply
+    // path itself — the rate default comes from `preApply.suggestedRate`
+    // per REQ-A4, not from the insight's `recommendedRate`. The
+    // pre-fetch is still issued per the #426 AC ("Pre-fetch via
+    // Promise.all: applyData + applyQuestions + rateInsight") so the
+    // wire-traffic shape matches what the mobile app's apply screen
+    // issues (the insight is what the mobile app shows alongside the
+    // rate input).
+    // Future widening: surface the insight in the apply outcome so
+    // callers can render it post-apply.
+    const [preApply, questions] = await Promise.all([
+        applyData(token, jobId),
+        applyQuestions(token, jobId),
+        rateInsight(token, jobId),
+    ]);
+    // Structural validation: every answer's id must resolve against
+    // the inventory. The id-field name is asymmetric per the recovered
+    // SDL — matcher answers use `id`, expertise answers use
+    // `questionId` (see {@link validateAnswerIds} for the rationale).
+    const matcherIds = new Set(questions.matcherQuestions.map((q) => q.identifier));
+    const expertiseIds = new Set(questions.expertiseQuestions.map((q) => q.identifier));
+    validateAnswerIds(input.matcherAnswers, matcherIds, "matcherAnswers", "id");
+    validateAnswerIds(input.expertiseAnswers, expertiseIds, "expertiseAnswers", "questionId");
+    // Rate default per REQ-A4 — caller-supplied overrides
+    // `PreApplyData.suggestedRate`. Throw `MUTATION_ERROR` if neither
+    // source produces a rate; the wire `$requestedHourlyRate` is
+    // `BigDecimal!` (non-null).
+    const requestedHourlyRate = input.requestedHourlyRate ?? preApply.suggestedRate;
+    if (requestedHourlyRate === null) {
+        throw new ApplicationsError("MUTATION_ERROR", "requestedHourlyRate is required and could not be defaulted from PreApplyData.suggestedRate — pass an explicit rate.");
+    }
+    const variables = {
+        id: jobId,
+        comment: input.message ?? null,
+        matcherQuestionsAnswers: input.matcherAnswers ?? null,
+        expertiseQuestionsAnswers: input.expertiseAnswers ?? null,
+        consentIssued: true,
+        requestedHourlyRate,
+        talentCard: input.pitchData ?? null,
+    };
+    const data = await callGatewayNoViewer(token, "JobApply", JOB_APPLY_MUTATION, variables);
+    if (data.job === null || data.job.apply === null) {
+        throw new ApplicationsError("UNKNOWN", "JobApply returned a null payload.");
+    }
+    const payload = data.job.apply;
+    if (!payload.success) {
+        // Map the wire's `already_applied` key to the typed
+        // `ALREADY_APPLIED` code so callers can render a targeted "you
+        // already applied" hint. Other `success: false` envelopes flow
+        // through the generic `MUTATION_ERROR` taxonomy.
+        const errors = payload.errors ?? [];
+        if (errors.some((e) => e.key === "already_applied")) {
+            throw new ApplicationsError("ALREADY_APPLIED", `You have already applied to job "${jobId}". Run \`ttctl applications show <activity-id>\` to find your existing application.`);
+        }
+        throw new ApplicationsError("MUTATION_ERROR", formatMutationErrors("JobApply failed", errors));
+    }
+    if (payload.job === null || payload.job.activityItem === null) {
+        throw new ApplicationsError("UNKNOWN", "JobApply returned success but the job / activityItem echo was null.");
+    }
+    return { kind: "applied", result: projectJobApplicationRecord(payload.job.activityItem) };
+}
+// Captured operation document at
+// `../research/graphql/gateway/operations/mobile/SimilarJobQuestionAnswers.graphql`
+// and `research/apk/decoded/smali/fn/ji.smali:89` (verbatim:
+// `query SimilarJobQuestionAnswers($id: ID!) { viewer { __typename id
+// jobPositionAnswers(filters: { forQuestionsSimilarToQuestionId: $id
+// uniqueAnswer: true } , pageSize: 10) { __typename nodes
+// { __typename id answer createdAt } } } }`).
+//
+// Schema gaps:
+//   - `viewer.jobPositionAnswers(filters:, pageSize:)` — the
+//     synthesized schema declares the field as
+//     `viewer.jobPositionAnswers: [JobPositionAnswer]!` with no args
+//     (line 814). The captured op passes both `filters` (a
+//     `JobPositionAnswerFiltersInput { forQuestionsSimilarToQuestionId,
+//     uniqueAnswer }`) and `pageSize`. Empirically these work — the
+//     mobile app calls this every time the apply screen renders a
+//     question autocomplete; the live E2E + T1 snapshot are the
+//     authority.
+//   - The return shape on the wire is a connection-like
+//     `{ nodes: JobPositionAnswer[] }` rather than the schema's bare
+//     `[JobPositionAnswer]!` list. The captured op selects `nodes`
+//     verbatim; the projection unwraps to the bare list.
+//   - `JobPositionAnswer.createdAt` is not declared in the synthesized
+//     SDL (`type JobPositionAnswer` at line 1134 carries only `answer`,
+//     `id`, `question`). The captured op selects it anyway — same gap
+//     pattern as `availabilityRequest.metadata.offeredHourlyRate` (#410)
+//     where the trimmed mobile selection extends the schema. T1 snapshot
+//     is the authority.
+const SIMILAR_JOB_QUESTION_ANSWERS_QUERY = `query SimilarJobQuestionAnswers($id: ID!) {
+  viewer {
+    __typename
+    id
+    jobPositionAnswers(filters: { forQuestionsSimilarToQuestionId: $id, uniqueAnswer: true }, pageSize: 10) {
+      __typename
+      nodes {
+        __typename
+        id
+        answer
+        createdAt
+      }
+    }
+  }
+}`;
+/**
+ * Project the wire's `jobPositionAnswers.nodes[]` into the public
+ * {@link SimilarJobAnswer}[] shape. Filters list-entry nulls
+ * defensively (the schema declares `[JobPositionAnswer]!` as a
+ * non-null LIST with nullable entries; the captured op honors the
+ * same nullability); the resulting list always carries non-null
+ * entries.
+ */
+function projectSimilarAnswers(nodes) {
+    if (nodes == null)
+        return [];
+    return nodes
+        .filter((n) => n !== null)
+        .map((n) => ({ id: n.id, answer: n.answer, createdAt: n.createdAt }));
+}
+/**
+ * Fetch one question's similar-answer suggestions from the gateway.
+ * Internal helper; the public surface is {@link similarAnswers} which
+ * fans out across the full question inventory of a job.
+ *
+ * `questionId` is the `ApplicationQuestion.identifier` (either matcher
+ * or expertise — the wire accepts both since they're both `Node`-typed
+ * via `JobPositionQuestion.id` / `JobExpertiseQuestion.id`).
+ *
+ * Bad-id behavior: an unknown `questionId` surfaces as the shared
+ * Relay decode error pattern (`Node id ... resolves to ...`) and is
+ * remapped to `NOT_FOUND` via the widened
+ * {@link NOT_FOUND_MESSAGE_PATTERN}.
+ *
+ * @throws `ApplicationsError("NOT_FOUND")` when the questionId
+ *   doesn't resolve.
+ * @throws `ApplicationsError("NO_VIEWER")` when the session is valid
+ *   but no viewer is bound (defensive — `callGateway` with
+ *   `requireViewer: true` already raises this case).
+ */
+async function similarAnswersForQuestion(token, questionId) {
+    let data;
+    try {
+        data = await callGateway(token, "SimilarJobQuestionAnswers", SIMILAR_JOB_QUESTION_ANSWERS_QUERY, { id: questionId });
+    }
+    catch (err) {
+        if (err instanceof ApplicationsError &&
+            err.code === "GRAPHQL_ERROR" &&
+            NOT_FOUND_MESSAGE_PATTERN.test(err.message)) {
+            throw new ApplicationsError("NOT_FOUND", `No question found with id "${questionId}" (or you don't have access to it).`, { cause: err });
+        }
+        throw err;
+    }
+    if (data.viewer === null) {
+        throw new ApplicationsError("NO_VIEWER", "Session is valid but no viewer is bound to it.");
+    }
+    // The wire returns `jobPositionAnswers: null` for unknown ids on
+    // some accounts (instead of a top-level GraphQL error). Treat the
+    // null connection as "no similar answers" rather than NOT_FOUND —
+    // the wire authoritatively returned a successful response.
+    if (data.viewer.jobPositionAnswers === null)
+        return [];
+    return projectSimilarAnswers(data.viewer.jobPositionAnswers.nodes);
+}
+/**
+ * Fetch the talent's similar-answer suggestions for every question on
+ * a job's apply form (#452).
+ *
+ * Returns one {@link SimilarJobAnswerGroup} per question — matcher
+ * AND expertise. The order mirrors the underlying
+ * {@link applyQuestions} inventory (matcher questions first, then
+ * expertise; server-supplied order within each section).
+ *
+ * **Cardinality**: N+1 wire calls — first an {@link applyQuestions}
+ * fetch to resolve the question identifier list, then N parallel
+ * `SimilarJobQuestionAnswers` calls (one per question) via
+ * `Promise.all`. The fan-out matches the mobile app's apply-screen
+ * autocomplete behavior; aggregating server-side is not exposed by
+ * the wire.
+ *
+ * **Bad-id behavior**: a bad `jobId` surfaces NOT_FOUND from
+ * `applyQuestions` (same mapping as the rest of the pre-apply suite).
+ * A per-question `SimilarJobQuestionAnswers` call that surfaces
+ * NOT_FOUND propagates verbatim via `Promise.all`'s reject-on-first
+ * — intentional: callers that want graceful per-question fallback
+ * (e.g. the CLI's `--suggest-answers` flag) should catch the rejection
+ * and continue without suggestions.
+ *
+ * **Performance**: when the job has zero questions, the call resolves
+ * to `[]` after the single `applyQuestions` fetch — no wasted parallel
+ * round-trips. When the job has questions but the talent's account
+ * has no similar-job history, each per-question call returns an empty
+ * `suggestions` array; surface the empty grouping verbatim.
+ *
+ * **Off the critical apply path**: this fn is NOT called from
+ * {@link apply}. It's opt-in via the CLI's `--suggest-answers` flag
+ * (#452) and the MCP's `ttctl_jobs_apply_similar_answers` tool. The
+ * design rationale is in the ADR-008 follow-ups thread.
+ *
+ * @param token - Bearer token from the resolved auth config.
+ * @param jobId - The `TalentJob.id` to resolve questions against.
+ * @throws `ApplicationsError("NOT_FOUND")` when the jobId or a
+ *   resolved questionId doesn't resolve.
+ * @throws `ApplicationsError("NO_VIEWER")` for sessions with no
+ *   bound viewer.
+ */
+export async function similarAnswers(token, jobId) {
+    const questions = await applyQuestions(token, jobId);
+    const allIdentifiers = [
+        ...questions.matcherQuestions.map((q) => q.identifier),
+        ...questions.expertiseQuestions.map((q) => q.identifier),
+    ];
+    if (allIdentifiers.length === 0)
+        return [];
+    const suggestions = await Promise.all(allIdentifiers.map((qid) => similarAnswersForQuestion(token, qid)));
+    return allIdentifiers.map((questionId, i) => ({ questionId, suggestions: suggestions[i] ?? [] }));
+}
+export const INTERVIEW_STATUSES = [
+    "ACCEPTED",
+    "MISSED",
+    "PENDING",
+    "REJECTED",
+    "SCHEDULED",
+    "TIME_ACCEPTED",
+    "TIME_REJECTED",
+];
+// Trimmed strict subset of the captured Interview op in
+// `research/graphql/gateway/operations/mobile/Interview.graphql`. The
+// captured doc selects via the `interviewWithJobActivityFields →
+// jobActivityItemData` cascade; this trim drops the activity-item
+// cascade (the caller already has the activity row from
+// `applications.show`) and keeps only the interview-specific selection.
+// `statuses: ALL` keeps parity with the captured op so any interview
+// state is fetchable.
+const INTERVIEW_QUERY = `query Interview($id: ID!) {
+  viewer {
+    __typename
+    id
+    interview(id: $id, statuses: ALL) {
+      __typename
+      id
+      interviewStatus: statusV2 { __typename value }
+      kind
+      interviewType
+      interviewTime
+      information
+      initiator
+      scheduledAtTimes
+      schedulingComment
+      interviewMethod {
+        __typename
+        typeV2
+        conferenceUrl
+        resource
+      }
+      interviewContacts {
+        __typename
+        id
+        fullName
+        email
+        phoneNumber
+        main
+        position
+        timeZone { __typename value location }
+      }
+      guide { __typename id }
+      talentNotes {
+        __typename
+        id
+        section
+        note
+      }
+      job {
+        __typename
+        id
+        activityItem { __typename id }
+      }
+      updatedAt
+    }
+  }
+}`;
+function projectInterviewContact(c) {
+    return {
+        id: c.id,
+        fullName: c.fullName ?? null,
+        email: c.email ?? null,
+        phoneNumber: c.phoneNumber ?? null,
+        position: c.position ?? null,
+        main: c.main ?? null,
+        timeZone: c.timeZone == null
+            ? null
+            : {
+                value: c.timeZone.value ?? null,
+                location: c.timeZone.location ?? null,
+            },
+    };
+}
+function projectInterviewDetail(w) {
+    return {
+        id: w.id,
+        status: (w.interviewStatus?.value ?? null),
+        kind: (w.kind ?? null),
+        interviewType: w.interviewType ?? null,
+        interviewTime: w.interviewTime ?? null,
+        information: w.information ?? null,
+        initiator: w.initiator ?? null,
+        scheduledAtTimes: (w.scheduledAtTimes ?? []).filter((s) => typeof s === "string"),
+        schedulingComment: w.schedulingComment ?? null,
+        method: w.interviewMethod == null
+            ? null
+            : {
+                typeV2: w.interviewMethod.typeV2 ?? null,
+                conferenceUrl: w.interviewMethod.conferenceUrl ?? null,
+                resource: w.interviewMethod.resource ?? null,
+            },
+        contacts: (w.interviewContacts ?? [])
+            .filter((c) => c != null)
+            .map(projectInterviewContact),
+        guideId: w.guide?.id ?? null,
+        talentNotes: (w.talentNotes ?? [])
+            .filter((n) => n != null)
+            .map((n) => ({
+            id: n.id,
+            section: n.section ?? null,
+            note: n.note ?? null,
+        })),
+        job: w.job == null
+            ? null
+            : {
+                id: w.job.id,
+                activityItemId: w.job.activityItem?.id ?? null,
+            },
+        updatedAt: w.updatedAt ?? null,
+    };
+}
+/**
+ * Read one `TalentInterview` by id via the mobile-gateway `Interview`
+ * query (#439). Sibling sub-namespace to the top-level activity-row
+ * leaves (`list` / `show` / `stats`) — fetches the rich interview
+ * detail once the user knows the id from `applications show
+ * <activityId>` (the `Interview: <id>` line).
+ *
+ * @throws `ApplicationsError("NOT_FOUND")` when the id doesn't resolve
+ *   to an interview the signed-in user can see, OR when the wire
+ *   surfaces a `NOT_FOUND_MESSAGE_PATTERN`-matched GraphQL error
+ *   (`Record not found` / `Invalid ID` / Relay `Node id ... resolves to`).
+ * @throws `ApplicationsError("NO_VIEWER")` when the session is valid
+ *   but no viewer is bound.
+ */
+async function interviewsShow(token, id) {
+    let data;
+    try {
+        data = await callGateway(token, "Interview", INTERVIEW_QUERY, { id });
+    }
+    catch (err) {
+        if (err instanceof ApplicationsError &&
+            err.code === "GRAPHQL_ERROR" &&
+            NOT_FOUND_MESSAGE_PATTERN.test(err.message)) {
+            throw new ApplicationsError("NOT_FOUND", `No interview found with id "${id}" (or you don't have access to it).`, {
+                cause: err,
+            });
+        }
+        throw err;
+    }
+    if (data.viewer === null) {
+        // Defensive — `callGateway` with `requireViewer: true` already
+        // raises `NO_VIEWER` for this case; keep the check for type
+        // narrowing parity with sibling `show()` / `stats()`.
+        throw new ApplicationsError("NO_VIEWER", "Session is valid but no viewer is bound to it.");
+    }
+    if (data.viewer.interview === null) {
+        throw new ApplicationsError("NOT_FOUND", `No interview found with id "${id}" (or you don't have access to it).`);
+    }
+    return projectInterviewDetail(data.viewer.interview);
+}
+// Trimmed strict subset of the captured `GetInterviewNotes` op in
+// `research/graphql/gateway/operations/portal/GetInterviewNotes.graphql`.
+// The captured doc selects a heavy cascade (~25 types via `JobClient`,
+// `JobOperationsFragment`, `JobMatcherData`, `JobSkillV2Data`,
+// `JobIndustriesData`, etc.); this trim drops everything except the
+// notes-specific selection on
+// `viewer.job(id).activityItem.interview.{id, kind, talentNotes{…}}`.
+// Authoritative wire shape is the captured doc; selection is the
+// projection contract.
+const GET_INTERVIEW_NOTES_QUERY = `query GetInterviewNotes($jobId: ID!) {
+  viewer {
+    __typename
+    id
+    job(id: $jobId) {
+      __typename
+      activityItem {
+        __typename
+        interview {
+          __typename
+          id
+          kind
+          talentNotes { __typename id note section }
+        }
+      }
+    }
+  }
+}`;
+/**
+ * Read the talent's prep notes for the interview attached to a given
+ * job via the portal-side `GetInterviewNotes` query (#440). Sub-sub-
+ * namespace leaf of `applications.interviews.*` — wraps the same
+ * read-only path the portal matcher UI uses to load interview notes.
+ *
+ * @param token   Captured bearer.
+ * @param jobId   `TalentJob.id` (NOT the interview id). Discover via
+ *                `applications interview show <interviewId>` (the
+ *                `Job → Job id` line, populated by the #439 projection)
+ *                or `applications show <activityId>`.
+ *
+ * @throws `ApplicationsError("NOT_FOUND")` when the job id doesn't
+ *   resolve to a job the signed-in user can see, OR when the wire
+ *   surfaces a `NOT_FOUND_MESSAGE_PATTERN`-matched GraphQL error
+ *   (`Record not found` / `Invalid ID` / Relay `Node id ... resolves to`).
+ * @throws `ApplicationsError("NO_VIEWER")` when the session is valid
+ *   but no viewer is bound.
+ */
+async function interviewsNotesShow(token, jobId) {
+    let data;
+    try {
+        data = await callGateway(token, "GetInterviewNotes", GET_INTERVIEW_NOTES_QUERY, { jobId });
+    }
+    catch (err) {
+        if (err instanceof ApplicationsError &&
+            err.code === "GRAPHQL_ERROR" &&
+            NOT_FOUND_MESSAGE_PATTERN.test(err.message)) {
+            throw new ApplicationsError("NOT_FOUND", `No job found with id "${jobId}" (or you don't have access to it).`, {
+                cause: err,
+            });
+        }
+        throw err;
+    }
+    if (data.viewer === null) {
+        // Defensive — `callGateway` with `requireViewer: true` already
+        // raises `NO_VIEWER` for this case; keep the check for type
+        // narrowing parity with sibling leaves.
+        throw new ApplicationsError("NO_VIEWER", "Session is valid but no viewer is bound to it.");
+    }
+    if (data.viewer.job === null) {
+        throw new ApplicationsError("NOT_FOUND", `No job found with id "${jobId}" (or you don't have access to it).`);
+    }
+    const interview = data.viewer.job.activityItem?.interview ?? null;
+    return {
+        jobId,
+        interviewId: interview?.id ?? null,
+        interviewKind: (interview?.kind ?? null),
+        notes: (interview?.talentNotes ?? [])
+            .filter((n) => n != null)
+            .map((n) => ({
+            id: n.id,
+            section: n.section ?? null,
+            note: n.note ?? null,
+        })),
+    };
+}
+export const INTERVIEW_GUIDE_SECTION_IDENTIFIERS = [
+    "ASK_YOUR_CLIENT",
+    "GAPS",
+    "JOB_HIGHLIGHTS",
+    "POTENTIAL_QUESTIONS",
+    "PRO_TIPS",
+    "STRENGTHS",
+];
+export const INTERVIEW_GUIDE_TIP_IDENTIFIERS = [
+    "BE_PRESENTABLE",
+    "CAMERA_ON",
+    "DONT_DISCUSS_RATE",
+    "GAP_ANALYSIS",
+    "HIRING_FACTORS",
+    "JOB_SUMMARY",
+    "PROFILE_REFERENCES",
+    "QUESTIONS_TO_ASK",
+    "QUESTIONS_TO_PREPARE_FOR",
+    "SMALL_TALK",
+    "STANDARD_QUESTIONS",
+    "STRENGTHS_OVERLAP",
+];
+// Trimmed strict subset of the captured `InterviewGuide` op in
+// `research/graphql/gateway/operations/mobile/InterviewGuide.graphql`.
+// The captured doc selects a heavy cascade
+// (`interviewContacts` + `job → jobData` + `client` + `mobileFeedbackForm`);
+// this trim drops everything except the guide-specific selection on
+// `viewer.interview(id).guide.{id, sections[].{identifier, title,
+// subtitle, tips[].{identifier, title, content, hardcodedContent}}}`.
+// Authoritative wire shape is the captured doc; selection is the
+// projection contract. `statuses: ALL` keeps parity with the captured
+// op so any interview state's guide is fetchable.
+const INTERVIEW_GUIDE_QUERY = `query InterviewGuide($id: ID!) {
+  viewer {
+    __typename
+    id
+    interview(id: $id, statuses: ALL) {
+      __typename
+      id
+      guide {
+        __typename
+        id
+        sections {
+          __typename
+          identifier
+          title
+          subtitle
+          tips {
+            __typename
+            identifier
+            title
+            content
+            hardcodedContent
+          }
+        }
+      }
+    }
+  }
+}`;
+/**
+ * Read the interview-prep guide content (sections + tips) for one
+ * interview via the mobile-gateway `InterviewGuide` query (#470).
+ * Sub-sub-namespace leaf of `applications.interviews.*` — wraps the
+ * mobile-portal interview-prep view that talents use to prepare.
+ *
+ * @param token        Captured bearer.
+ * @param interviewId  `TalentInterview.id` (NOT the guide id). Discover
+ *                     via `applications interview show <interviewId>`
+ *                     or `applications show <activityId>`.
+ *
+ * @throws `ApplicationsError("NOT_FOUND")` when the id doesn't resolve
+ *   to an interview the signed-in user can see, OR when the wire
+ *   surfaces a `NOT_FOUND_MESSAGE_PATTERN`-matched GraphQL error
+ *   (`Record not found` / `Invalid ID` / Relay `Node id ... resolves to`).
+ * @throws `ApplicationsError("NO_VIEWER")` when the session is valid
+ *   but no viewer is bound.
+ */
+async function interviewsGuideShow(token, interviewId) {
+    let data;
+    try {
+        data = await callGateway(token, "InterviewGuide", INTERVIEW_GUIDE_QUERY, { id: interviewId });
+    }
+    catch (err) {
+        if (err instanceof ApplicationsError &&
+            err.code === "GRAPHQL_ERROR" &&
+            NOT_FOUND_MESSAGE_PATTERN.test(err.message)) {
+            throw new ApplicationsError("NOT_FOUND", `No interview found with id "${interviewId}" (or you don't have access to it).`, { cause: err });
+        }
+        throw err;
+    }
+    if (data.viewer === null) {
+        // Defensive — `callGateway` with `requireViewer: true` already
+        // raises `NO_VIEWER` for this case; keep the check for type
+        // narrowing parity with sibling leaves.
+        throw new ApplicationsError("NO_VIEWER", "Session is valid but no viewer is bound to it.");
+    }
+    if (data.viewer.interview === null) {
+        throw new ApplicationsError("NOT_FOUND", `No interview found with id "${interviewId}" (or you don't have access to it).`);
+    }
+    const wire = data.viewer.interview;
+    return {
+        interviewId,
+        guideId: wire.guide?.id ?? null,
+        sections: (wire.guide?.sections ?? [])
+            .filter((s) => s != null)
+            .map((s) => ({
+            identifier: (s.identifier ?? null),
+            title: s.title ?? null,
+            subtitle: s.subtitle ?? null,
+            tips: (s.tips ?? [])
+                .filter((t) => t != null)
+                .map((t) => ({
+                identifier: (t.identifier ?? null),
+                title: t.title ?? null,
+                content: t.content ?? null,
+                hardcodedContent: t.hardcodedContent ?? null,
+            })),
+        })),
+    };
+}
+/**
+ * `applications.interviews.*` sub-namespace. Read-only leaves for
+ * interview-detail access — sibling to the top-level activity-row
+ * leaves on this module. Sub-namespace grouping pattern follows
+ * `payments.rate.*` (#447) and `payments.payouts.*` / `payments.methods.*`
+ * (#149); the plural form here matches `payouts` / `methods` for
+ * collection-style namespaces.
+ *
+ * Sub-sub-namespaces:
+ *   - `interviews.notes.*` (#440) — portal-side notes-focused projection.
+ *     `notes.show(jobId)` is the lightweight read of the talent's prep
+ *     notes for one job's interview, paired with the heavier
+ *     `interviews.show(interviewId)` from #439.
+ *   - `interviews.guide.*` (#470) — mobile-gateway guide-content
+ *     projection. `guide.show(interviewId)` is the read of the
+ *     interview-prep guide (sections + tips). Paired with #439 —
+ *     `interviews.show` surfaces the guide-id presence indicator;
+ *     `interviews.guide.show` fetches the full content.
+ */
+export const interviews = {
+    show: interviewsShow,
+    notes: {
+        show: interviewsNotesShow,
+    },
+    guide: {
+        show: interviewsGuideShow,
+    },
+};
+export const AVAILABILITY_REQUEST_STATUSES = [
+    "CANCELLED",
+    "CONFIRMED",
+    "EXPIRED",
+    "PENDING",
+    "REJECTED",
+    "WITHDRAWN",
+];
+// Trimmed strict subset of the captured AvailabilityRequest op in
+// `research/graphql/gateway/operations/mobile/AvailabilityRequest.graphql`.
+// The captured doc selects `job { ...jobData }` (a ~25-type cascade
+// touching `Unknown`-typed positions) plus the `AvailabilityRequest`
+// gap fields; this trim keeps only the well-typed selection the CLI /
+// MCP renders. The `metadata` selection mirrors
+// `GET_AVAILABILITY_REQUEST_KIND_QUERY` — `__typename` per union variant
+// (drives {@link kindFromMetadataTypename}) plus `offeredHourlyRate` on
+// the Fixed variant. `job` is trimmed to the {@link ApplicationJobRef}
+// shape.
+const AVAILABILITY_REQUEST_QUERY = `query AvailabilityRequest($id: ID!) {
+  viewer {
+    __typename
+    id
+    availabilityRequest(id: $id) {
+      __typename
+      id
+      createdAt
+      updatedAt
+      answeredAt
+      comment
+      jirStatus: statusV2 { __typename value }
+      metadata {
+        __typename
+        ... on AvailabilityRequestFixedMetadata {
+          __typename
+          offeredHourlyRate { __typename decimal verbose }
+        }
+        ... on AvailabilityRequestFlexibleMetadata { __typename }
+        ... on MarketplaceAvailabilityRequestFlexibleMetadata { __typename }
+      }
+      job {
+        __typename
+        id
+        title
+        url
+        client { __typename id fullName }
+      }
+    }
+  }
+}`;
+function projectAvailabilityRequestDetail(w) {
+    const offered = w.metadata?.offeredHourlyRate;
+    const fixedRate = offered != null && typeof offered.decimal === "string" && typeof offered.verbose === "string"
+        ? { decimal: offered.decimal, verbose: offered.verbose }
+        : null;
+    return {
+        id: w.id,
+        status: (w.jirStatus?.value ?? null),
+        kind: kindFromMetadataTypename(w.metadata?.__typename ?? null),
+        fixedRate,
+        comment: w.comment ?? null,
+        createdAt: w.createdAt ?? null,
+        updatedAt: w.updatedAt ?? null,
+        answeredAt: w.answeredAt ?? null,
+        job: w.job == null
+            ? null
+            : {
+                id: w.job.id,
+                title: w.job.title ?? null,
+                url: w.job.url ?? null,
+                client: w.job.client == null ? null : { id: w.job.client.id, fullName: w.job.client.fullName ?? null },
+            },
+    };
+}
+/**
+ * Read one `AvailabilityRequest` by id via the mobile-gateway
+ * `AvailabilityRequest` query (#442). Sibling sub-namespace to the
+ * top-level activity-row leaves (`list` / `show` / `stats`) and to
+ * `interviews.show` (#439) — fetches the rich availability-request
+ * detail once the user knows the id from `applications show
+ * <activityId>` (the `Availability request: <id>` line). The id is the
+ * same `AvailabilityRequest.id` the #411 `confirm` / `reject` write-side
+ * ops accept.
+ *
+ * @throws `ApplicationsError("NOT_FOUND")` when the id doesn't resolve
+ *   to an availability request the signed-in user can see, OR when the
+ *   wire surfaces a `NOT_FOUND_MESSAGE_PATTERN`-matched GraphQL error
+ *   (`Record not found` / `Invalid ID` / Relay `Node id ... resolves to`).
+ * @throws `ApplicationsError("NO_VIEWER")` when the session is valid
+ *   but no viewer is bound.
+ */
+async function availabilityRequestsShow(token, id) {
+    let data;
+    try {
+        data = await callGateway(token, "AvailabilityRequest", AVAILABILITY_REQUEST_QUERY, { id });
+    }
+    catch (err) {
+        if (err instanceof ApplicationsError &&
+            err.code === "GRAPHQL_ERROR" &&
+            NOT_FOUND_MESSAGE_PATTERN.test(err.message)) {
+            throw new ApplicationsError("NOT_FOUND", `No availability request found with id "${id}" (or you don't have access to it).`, { cause: err });
+        }
+        throw err;
+    }
+    if (data.viewer === null) {
+        // Defensive — `callGateway` with `requireViewer: true` already
+        // raises `NO_VIEWER` for this case; keep the check for type
+        // narrowing parity with sibling `interviews.show()`.
+        throw new ApplicationsError("NO_VIEWER", "Session is valid but no viewer is bound to it.");
+    }
+    if (data.viewer.availabilityRequest === null) {
+        throw new ApplicationsError("NOT_FOUND", `No availability request found with id "${id}" (or you don't have access to it).`);
+    }
+    return projectAvailabilityRequestDetail(data.viewer.availabilityRequest);
+}
+/**
+ * `applications.availabilityRequests.*` sub-namespace. Read-only leaf
+ * for availability-request-detail access — sibling to `interviews.*`
+ * (#439 / #440) and to the top-level activity-row leaves. The plural
+ * `availabilityRequests` form matches `interviews` / `payouts` /
+ * `methods` for collection-style namespaces; the #411 write-side ops
+ * (`confirm` / `reject` / `rejectReasons`) stay top-level flat exports
+ * (they predate the sub-namespace convention).
+ */
+export const availabilityRequests = {
+    show: availabilityRequestsShow,
+};
 //# sourceMappingURL=index.js.map