trackly-cli 0.6.2 → 0.7.0

package/README.md

@@ -99,7 +99,9 @@ trackly agent setup --client codex    # or claude / both
 trackly agent doctor
 ```
 
-The skill uses the profile and default resume in your Trackly account, asks only missing questions, fills user-approved saved jobs, and always stops before Submit. Greenhouse is fully supported; Ashby and Lever are best effort.
+The skill uses the profile and default resume in your Trackly account, asks only missing questions, fills user-approved saved jobs, and always stops before Submit. Support is fetched from Trackly at the start of every run: Greenhouse is full, Ashby and Lever are best effort, and 27 additional named ATS/provider classes use constrained guided mode. Employer-hosted unknown forms run only when Trackly binds them to a verified company domain. LinkedIn-hosted forms and unverified origins remain manual-only; a separately stored external application URL is evaluated under its own ATS and origin policy.
+
+Guided mode is deliberately fail-closed. The agent stops on credential entry, OTP/email verification, CAPTCHA/human verification, an unexpected employer or origin, a submit-only transition, or any field whose committed state cannot be observed. `trackly agent doctor` checks the local skill, MCP registration, protocol compatibility, declared browser/computer-use configuration, profile completeness, and default-resume metadata. Live semantic browser capability and the exact resume bytes are verified at the start of a real run.
 
 #### Claude Code one-liner
 

package/bin/trackly

@@ -969,7 +969,8 @@ async function cmdAgent(args) {
     console.log(color('bold', 'Trackly Apply doctor'));
     console.log(`Overall: ${color(report.ok ? 'green' : 'yellow', report.ok ? 'ready' : 'needs attention')}`);
     console.log(`Authenticated: ${report.authenticated ? 'yes' : 'no'}`);
-    console.log(`Protocol compatible: ${report.compatible ? 'yes' : 'no'}`);
+    console.log(`Protocol: ${report.protocol?.version || 'unavailable'}; compatible=${report.compatible ? 'yes' : 'no'}`);
+    console.log(`Semantic browser + computer use: ${report.browserControl.semanticReady ? 'ready' : 'not verified'}`);
     for (const client of report.clients) {
       console.log(`${client.client}: executable=${client.executable ? 'yes' : 'no'}, skill=${client.installed ? 'yes' : 'no'}, MCP=${client.mcpRegistered ? 'yes' : 'no'}`);
     }

package/contracts/trackly-apply-tools.json

@@ -1,5 +1,5 @@
 {
-  "contractVersion": "2.0.0",
+  "contractVersion": "3.0.0",
   "tools": {
     "trackly_get_apply_queue": "{limit:z.number().int().min(1).max(100).optional()}",
     "trackly_get_application_profile": "{includeSensitive:z.boolean().optional(),provider:z.string().max(100).optional(),companyId:z.string().max(100).optional()}",
@@ -7,9 +7,9 @@
     "trackly_update_application_profile": "{expectedRevision:z.number().int().min(1),source:z.enum(['web','ios','macos','codex','claude','mcp']).optional(),changes:z.array(z.discriminatedUnion('scope',[z.object({key:z.string().min(1).max(200),state:z.enum(['unknown','answered','intentionally_blank','declined']),value:z.any().optional(),scope:z.literal('global'),questionLabel:z.string().max(1000).optional()}),z.object({key:z.string().min(1).max(200),state:z.enum(['unknown','answered','intentionally_blank','declined']),value:z.any().optional(),scope:z.literal('provider'),scopeValue:z.string().min(1).max(200),questionLabel:z.string().max(1000).optional()}),z.object({key:z.string().min(1).max(200),state:z.enum(['unknown','answered','intentionally_blank','declined']),value:z.any().optional(),scope:z.literal('company'),scopeValue:z.string().min(1).max(200),questionLabel:z.string().max(1000).optional()})])).max(100).optional(),education:z.array(z.object({school:z.string().min(1).max(500),degree:z.string().max(500).nullable().optional(),fieldOfStudy:z.string().max(500).nullable().optional(),gpa:z.string().max(50).nullable().optional(),startDate:z.string().max(50).nullable().optional(),endDate:z.string().max(50).nullable().optional()})).max(20).optional(),confirmProfile:z.boolean().optional(),sensitiveStorageConsent:z.boolean().optional()}",
     "trackly_start_apply_run": "{jobId:z.number().int().min(1),clientName:z.string().max(100).optional()}",
     "trackly_get_apply_protocol": "{}",
-    "trackly_report_apply_observation": "{runId:z.number().int().min(1).optional(),provider:z.string().min(1).max(100),fieldLabel:z.string().min(1).max(1000),observationType:z.string().min(1).max(100),resolutionCode:z.string().max(100).optional(),metadata:z.object({controlType:z.string().max(100).optional(),required:z.boolean().optional(),errorCode:z.string().max(100).optional(),committed:z.boolean().optional()}).optional()}",
+    "trackly_report_apply_observation": "{runId:z.number().int().min(1),provider:z.string().regex(SAFE_OBSERVATION_CODE),fieldLabel:z.string().min(1).max(1000),observationType:z.string().regex(SAFE_OBSERVATION_CODE),resolutionCode:z.string().regex(SAFE_OBSERVATION_CODE).optional(),metadata:z.object({controlType:z.string().regex(SAFE_OBSERVATION_CODE).optional(),required:z.boolean().optional(),errorCode:z.string().regex(SAFE_OBSERVATION_CODE).optional(),committed:z.boolean(),scenarioCode:z.enum(APPLY_SCENARIO_CODES),browserSurface:z.enum(APPLY_BROWSER_SURFACES),browserBindingHash:z.string().regex(/^[a-f0-9]{64}$/).optional(),resumedAfterHandoff:z.boolean().optional()})}",
     "trackly_record_application_outcome": "{runId:z.number().int().min(1),outcome:z.enum(['review_ready','submitted','failed','blocked']),confirmation:z.string().max(500).optional()}",
-    "trackly_prepare_resume": "{runId:z.number().int().min(1)}",
+    "trackly_prepare_resume": "{runId:z.number().int().min(1),browserSurface:z.enum(APPLY_BROWSER_SURFACES),browserBindingHash:z.string().regex(/^[a-f0-9]{64}$/)}",
     "trackly_verify_prepared_resume": {
       "local": "{runId:z.number().int().min(1),confirmationId:z.string().min(1).max(200),exactLocalPath:z.string().min(1).max(4096),sha256:z.string().regex(/^[a-f0-9]{64}$/i),sizeBytes:z.number().int().min(1),expiresAt:z.string().datetime()}",
       "hosted": "{runId:z.number().int().min(1),confirmationId:z.string().min(1).max(200)}"

package/docs/trackly-tools.md

@@ -94,12 +94,12 @@ You can also pass `TRACKLY_API_KEY` as an environment variable for one-off runs.
 - **trackly_update_application_profile** — Save explicit answer states with optimistic concurrency and global/provider/company scope.
 - **trackly_start_apply_run** — Start a manual-submit browser run for a queued job.
 - **trackly_get_apply_protocol** — Get the current ATS support, browser integrity rules, and compatible skill version.
-- **trackly_report_apply_observation** — Report redacted ATS mechanics without answer values.
+- **trackly_report_apply_observation** — Report redacted ATS mechanics and actual scenario coverage without answer values or page text.
 - **trackly_record_application_outcome** — Record review readiness or a confirmed manual submission.
 - **trackly_prepare_resume** — Local MCP only: materialize the default resume in a private, expiring mode-0600 cache and return filename, size, SHA-256, exact local path, and visual-confirmation metadata. Hosted MCP returns a manual/local-agent requirement.
 - **trackly_verify_prepared_resume** — Local MCP only: immediately before attachment, recompute the user-confirmed resume hash and size, validate the exact path/run/expiration, and lock the file read-only. Any mismatch requires a fresh preview and confirmation.
 
-Apply contract v2 intentionally gives this verifier different local and hosted schemas: local MCP receives the full proof needed to inspect the private file, while hosted MCP accepts only run and confirmation identifiers and returns the manual/local-agent requirement. Local paths and fingerprints are never sent to the hosted verifier.
+Apply contract v3 intentionally gives this verifier different local and hosted schemas: local MCP receives the full proof needed to inspect the private file, while hosted MCP accepts only run and confirmation identifiers and returns the manual/local-agent requirement. Local paths and fingerprints are never sent to the hosted verifier. Version 3 also requires explicit committed-state evidence on every Apply observation.
 
 ### Maintenance behavior
 

package/lib/agent.js

@@ -7,12 +7,13 @@ const path = require('node:path');
 const { spawnSync } = require('node:child_process');
 const { apiRequest, downloadFile, getConfigPaths, hasAuth, maintenanceOutput } = require('./client');
 const { version: PACKAGE_VERSION } = require('../package.json');
-const SKILL_VERSION = '2.1.0';
+const SKILL_VERSION = '4.0.0';
 const CLI_USER_AGENT = `trackly-cli/${PACKAGE_VERSION}`;
 const MCP_USER_AGENT = `trackly-mcp/${PACKAGE_VERSION}`;
 
 const SKILL_NAME = 'trackly-apply';
 const SKILL_MAJOR = Number(SKILL_VERSION.split('.')[0]);
+const MIN_APPLY_PROTOCOL_VERSION = '3.0.0';
 const CACHE_TTL_MS = 2 * 60 * 60 * 1000;
 const MANAGED_FILE = '.trackly-managed.json';
 const RESUME_PROOF_FILE = '.trackly-resume-proof.json';
@@ -597,15 +598,23 @@ function validateResumeFile(download) {
   };
 }
 
-async function prepareResume(runId, userAgent = MCP_USER_AGENT) {
+async function prepareResume(runId, browserSurface, browserBindingHash, userAgent = MCP_USER_AGENT) {
   if (!hasAuth()) throw new Error('Authenticate first with `trackly login` or `trackly config --api-key ...`.');
   const normalizedRunId = Number(runId);
   if (!Number.isInteger(normalizedRunId) || normalizedRunId < 1) {
     throw new Error('A valid Trackly Apply run ID is required before preparing a resume.');
   }
+  if (!['codex_in_app', 'chrome_extension', 'claude_in_chrome'].includes(browserSurface)) {
+    throw new Error('A supported semantic browser surface is required before preparing a resume.');
+  }
+  if (!/^[a-f0-9]{64}$/.test(String(browserBindingHash || ''))) {
+    throw new Error('A lowercase SHA-256 browser binding is required before preparing a resume.');
+  }
   cleanResumeCache();
   const download = await downloadFile(
-    `/api/jobscout/application-profile/default-resume?runId=${normalizedRunId}`,
+    `/api/jobscout/application-profile/default-resume?runId=${normalizedRunId}`
+      + `&browserSurface=${encodeURIComponent(browserSurface)}`
+      + `&browserBindingHash=${browserBindingHash}`,
     userAgent,
   );
   try {
@@ -618,17 +627,41 @@ async function prepareResume(runId, userAgent = MCP_USER_AGENT) {
   }
 }
 
+function protocolAtLeast(version, minimum = MIN_APPLY_PROTOCOL_VERSION) {
+  const parse = (value) => String(value || '').split('.').map((part) => Number(part));
+  const actual = parse(version);
+  const required = parse(minimum);
+  if (actual.length < 2 || actual.some((part) => !Number.isInteger(part) || part < 0)) return false;
+  for (let index = 0; index < Math.max(actual.length, required.length); index++) {
+    const left = actual[index] || 0;
+    const right = required[index] || 0;
+    if (left !== right) return left > right;
+  }
+  return true;
+}
+
+function liveBrowserReady(browserControl) {
+  return (browserControl?.codex === true && browserControl?.codexComputerUse === true)
+    || browserControl?.claude === true;
+}
+
 async function doctorAgent() {
   const cache = cleanResumeCache();
+  const codexBrowser = fs.existsSync(path.join(os.homedir(), '.codex', 'plugins', 'cache', 'openai-bundled', 'chrome'));
+  const codexComputerUse = fs.existsSync(path.join(os.homedir(), '.codex', 'plugins', 'cache', 'openai-bundled', 'computer-use'));
+  const browserControl = {
+    codex: codexBrowser,
+    codexComputerUse,
+    claude: null,
+  };
   const report = {
     skillVersion: SKILL_VERSION,
     authenticated: hasAuth(),
     clients: ['codex', 'claude'].map(inspectClient),
     browserControl: {
-      codex: fs.existsSync(path.join(os.homedir(), '.codex', 'plugins', 'cache', 'openai-bundled', 'chrome')),
-      codexComputerUse: fs.existsSync(path.join(os.homedir(), '.codex', 'plugins', 'cache', 'openai-bundled', 'computer-use')),
-      claude: null,
-      note: 'Capability is client-managed; verify Chrome/browser and computer-use tools are enabled before a live run.',
+      ...browserControl,
+      semanticReady: liveBrowserReady(browserControl),
+      note: 'A live run requires both semantic browser control and computer use. Claude capability must be verified by the active client before the run starts.',
     },
     cache,
     protocol: null,
@@ -649,7 +682,8 @@ async function doctorAgent() {
       completeness: profile.profile?.completeness,
       hasDefaultResume: Boolean(profile.profile?.defaultResume),
     };
-    report.compatible = Number(report.protocol.compatibleSkillMajor) === SKILL_MAJOR;
+    report.compatible = Number(report.protocol.compatibleSkillMajor) === SKILL_MAJOR
+      && protocolAtLeast(report.protocol.version, MIN_APPLY_PROTOCOL_VERSION);
     if (report.profile.hasDefaultResume) {
       report.resume = {
         available: true,
@@ -662,6 +696,7 @@ async function doctorAgent() {
   }
   report.ok = report.authenticated
     && report.compatible
+    && report.browserControl.semanticReady
     && report.clients.some((client) => client.executable && client.installed && client.mcpRegistered)
     && Boolean(report.profile?.hasDefaultResume)
     && report.resume.available
@@ -681,6 +716,7 @@ module.exports = {
   CLI_USER_AGENT,
   MCP_USER_AGENT,
   SKILL_MAJOR,
+  MIN_APPLY_PROTOCOL_VERSION,
   SKILL_NAME,
   bundledSkillDir,
   cacheDir,
@@ -689,8 +725,10 @@ module.exports = {
   clientSkillDir,
   doctorAgent,
   inspectClient,
+  liveBrowserReady,
   materializeResume,
   prepareResume,
+  protocolAtLeast,
   resumeConfirmation,
   resumeCacheName,
   resumeValidationStatus,

package/mcp/server.js

@@ -11,6 +11,13 @@ const { version: PACKAGE_VERSION } = require('../package.json');
 const MCP_USER_AGENT = `trackly-mcp/${PACKAGE_VERSION}`;
 const MCP_MAINTENANCE_ERROR_CODE = -32002;
 const AUTH_HINT = 'Run `trackly login` or set TRACKLY_API_KEY. Get a key at https://usetrackly.app (sign in → Settings → API Keys).';
+const APPLY_BROWSER_SURFACES = ['codex_in_app', 'chrome_extension', 'claude_in_chrome'];
+const APPLY_SCENARIO_CODES = [
+  'browser_reclaim', 'resume_upload', 'resume_parser_recheck', 'semantic_boolean_commit',
+  'custom_select_commit', 'multi_step_navigation', 'free_text_voice',
+  'required_error_sweep', 'final_consent', 'handoff_reclaim',
+];
+const SAFE_OBSERVATION_CODE = /^[a-z0-9][a-z0-9_:-]{0,99}$/;
 
 // Mirrors `granola-followup-app/src/services/region-classifier.ts:8` REGION_TAGS.
 // Keep in sync when the backend enum changes.
@@ -439,19 +446,23 @@ function createServer() {
 
   server.tool(
     'trackly_report_apply_observation',
-    'Report a redacted ATS mechanics observation. Never include answer values, addresses, contact data, OTPs, or free-form page content.',
+    'Report a redacted ATS mechanics or scenario-coverage observation. Never include answer values, addresses, contact data, OTPs, or free-form page content.',
     {
-      runId: z.number().int().min(1).optional(),
-      provider: z.string().min(1).max(100),
+      runId: z.number().int().min(1),
+      provider: z.string().regex(SAFE_OBSERVATION_CODE),
       fieldLabel: z.string().min(1).max(1000),
-      observationType: z.string().min(1).max(100),
-      resolutionCode: z.string().max(100).optional(),
+      observationType: z.string().regex(SAFE_OBSERVATION_CODE),
+      resolutionCode: z.string().regex(SAFE_OBSERVATION_CODE).optional(),
       metadata: z.object({
-        controlType: z.string().max(100).optional(),
+        controlType: z.string().regex(SAFE_OBSERVATION_CODE).optional(),
         required: z.boolean().optional(),
-        errorCode: z.string().max(100).optional(),
-        committed: z.boolean().optional(),
-      }).optional(),
+        errorCode: z.string().regex(SAFE_OBSERVATION_CODE).optional(),
+        committed: z.boolean(),
+        scenarioCode: z.enum(APPLY_SCENARIO_CODES),
+        browserSurface: z.enum(APPLY_BROWSER_SURFACES),
+        browserBindingHash: z.string().regex(/^[a-f0-9]{64}$/).optional(),
+        resumedAfterHandoff: z.boolean().optional(),
+      }),
     },
     wrapTool(async (params) => apiRequest('POST', '/api/jobscout/apply/observations', params, false, false, MCP_USER_AGENT), 'Failed to report apply observation')
   );
@@ -470,8 +481,13 @@ function createServer() {
   server.tool(
     'trackly_prepare_resume',
     'Download the authenticated default resume into a mode-0600 temporary Trackly cache and return exact-file proof for user confirmation before browser upload.',
-    { runId: z.number().int().min(1) },
-    wrapTool(async ({ runId }) => prepareResume(runId), 'Failed to prepare default resume')
+    {
+      runId: z.number().int().min(1),
+      browserSurface: z.enum(APPLY_BROWSER_SURFACES),
+      browserBindingHash: z.string().regex(/^[a-f0-9]{64}$/),
+    },
+    wrapTool(async ({ runId, browserSurface, browserBindingHash }) =>
+      prepareResume(runId, browserSurface, browserBindingHash), 'Failed to prepare default resume')
   );
 
   server.tool(
@@ -496,7 +512,7 @@ function createServer() {
       role: 'user',
       content: {
         type: 'text',
-        text: 'Fetch the Trackly Apply protocol and profile onboarding, resolve missing answers with me, and start the next approved queue run. Prepare the run-bound resume locally, show me its exact path, filename, size, SHA-256, run, and expiration, and obtain my explicit confirmation. Immediately before attachment, use the local verifier to validate the signed proof, recompute hash and size, check expiration, and lock the file read-only. Then fill the form, verify every required field, and stop before Submit. If maintenance interrupts the run, retain the run and browser context, wait for the advertised window, refetch protocol and profile state, and resume the existing agent_browser run. Never start a duplicate run, blindly retry a mutation, or click Submit.',
+        text: 'Fetch the Trackly Apply protocol, profile onboarding, profile, and approved queue. Resolve missing answers with me. Before starting anything, stop on every non-null executionBlocker and every manual_only item. Start only the selected approved queue item, require major(run.protocolVersion) === major(protocol.version), require protocol.compatibleSkillMajor === 4, preserve the stored version for a resumed run, and require its provider, atsCapability, required scenarios, and originPolicy to match the queue preflight. Reclaim semantic browser control, verify the exact job/run/tab binding, hash that value-free binding, and report the same-run browser_ready attestation with committed=true. Before entering private data, normalize every page, redirect, and data-receiving iframe URL; accept an exact authorized origin or hostname only when host === allowedDomain or host.endsWith("." + allowedDomain), never by substring or page text. For vendor-hosted ATS pages, execute the backend-owned originPolicy.tenantRule exactly after every redirect or data-receiving iframe change, including its extraction, exact-host-depth, locale, percent-decoding, normalization, and fail-closed semantics, then require the normalized result to equal originPolicy.verifiedAtsTenant; never invent or reinterpret a strategy token. Obey every capability stop condition. Determine whether the form has a semantically identified Resume or CV attachment control. Only when that specific control exists, prepare the run-bound resume locally with that browser surface and binding hash, show me its exact path, filename, size, SHA-256, run, and expiration, and obtain my explicit confirmation. Treat cover-letter, portfolio, transcript, and other supporting-document controls separately according to the profile and protocol; never upload a resume to them. Immediately before attaching the resume, use the local verifier to validate the signed proof, recompute hash and size, check expiration, and lock the file read-only. Fill the form through semantic controls, verify committed values and every required error, and report a same-run passed or corrected scenario_coverage observation with committed=true for every backend-required scenario except browser_reclaim, which is satisfied only by browser_ready with the binding hash. If a required scenario cannot pass, record blocked rather than review_ready. Stop before Submit. If maintenance interrupts the run, retain the run and browser context, wait for the advertised window, refetch protocol, queue, and profile state, and resume the existing agent_browser run. Never start a duplicate run, blindly retry a mutation, enter credentials or verification codes, evade human verification, or click Submit.',
       },
     }],
   }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trackly-cli",
-  "version": "0.6.2",
+  "version": "0.7.0",
   "mcpName": "io.github.trackly-app/trackly",
   "description": "AI job search CLI + hosted MCP server with OAuth. 128K+ jobs, 1,900+ companies, 40+ ATS. Works with Claude, ChatGPT, Cursor, Windsurf, Codex via hosted streamable-http or local stdio.",
   "bin": {

package/server.json

@@ -17,12 +17,12 @@
       ]
     }
   ],
-  "version": "0.6.2",
+  "version": "0.7.0",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "trackly-cli",
-      "version": "0.6.2",
+      "version": "0.7.0",
       "runtimeHint": "npx",
       "runtimeArguments": [
         {

package/skills/trackly-apply/SKILL.md

@@ -10,7 +10,7 @@ Use Trackly as the source of truth for profile answers, documents, queue decisio
 ## Non-negotiable rules
 
 1. Stop before Submit. Never click a submit-application button, even when the user previously approved submission or asks for full automation. The user submits manually.
-2. Treat a saved/check-later job as an execution instruction. Do not rescore, veto, or delay it based on fit. Surface only execution blockers such as a closed posting, unsupported ATS, missing answer, or verification challenge.
+2. Treat a saved/check-later job as an execution instruction. Do not rescore, veto, or delay it based on fit. Surface only execution blockers such as a closed posting, a protocol-declared manual-only ATS, missing answer, or verification challenge.
 3. Never invent immigration, authorization, EEO, education, compensation, consent, employment, referral, or communication answers.
 4. Never store OTPs, CAPTCHA answers, or human-verification codes. Do not evade anti-bot controls; pause for the user.
 5. Mark a job applied only after a real success page or the user explicitly confirms manual submission.
@@ -19,7 +19,7 @@ Use Trackly as the source of truth for profile answers, documents, queue decisio
 
 ## Start every run
 
-1. Call `trackly_get_apply_protocol`. Reject an incompatible major skill version and report that `trackly agent setup` must update the skill.
+1. Call `trackly_get_apply_protocol`. Skill 4.0 requires protocol major 3 (version 3.0.0 or newer) and `compatibleSkillMajor: 4`. Reject an older or incompatible major and report that the backend must finish updating or `trackly agent setup` must update the skill. This breaking gate prevents a pre-guided-mode skill or run from being reused under the stronger cross-ATS contract.
 2. Call `trackly_get_profile_onboarding` or fetch both the profile schema and application profile. Ask only unknown or unconfirmed fields.
 3. Save answers with `trackly_update_application_profile`:
    - Use `answered`, `intentionally_blank`, `declined`, or `unknown` exactly.
@@ -27,20 +27,40 @@ Use Trackly as the source of truth for profile answers, documents, queue decisio
    - Save ATS-specific behavior by provider and employer-specific facts by company.
    - Ask which scope applies when it is unclear.
    - Require explicit encrypted-storage consent before saving restricted profile values.
-4. Require the one-time profile confirmation, complete education entries, and a default resume before browser work.
+   - Use `employment.previously_worked_for_employer` only at company scope.
+   - Use `employment.has_close_relationship_at_employer` only at company scope.
+   - Use `location.requires_relocation_assistance` only at global scope.
+   - Keep `identity.pronouns` separate from `eeo.gender_identity`; save `eeo.gender_identity` only at global scope.
+   - Use `consent.future_opportunity_retention` only at company scope because one employer's optional retention choice is not consent for another employer.
+   - Treat an accuracy or truthfulness certification as a live per-run attestation. Never save that attestation to the reusable profile; ask and verify it on every application run.
+4. Require the one-time profile confirmation, complete education entries, and default-resume metadata before browser work. Do not prepare or upload the resume when the form has no attachment control.
 5. Call `trackly_get_apply_queue`. Select deterministically unless the user names a job. Do not replace the queue call with a fresh job search.
-6. Call `trackly_start_apply_run` for the selected job.
-7. Call `trackly_prepare_resume` with the active application run ID. If hosted MCP reports it unavailable, tell the user that local Trackly MCP or manual upload is required.
-8. Preserve the user’s filename returned by `trackly_prepare_resume`. Internal cache identifiers belong only in private parent directories and must never appear in the employer-facing upload filename.
-9. Before any upload, let the user inspect the exact prepared file returned by `trackly_prepare_resume`:
+   - Use the queue item's backend-owned `atsCapability`, `originPolicy`, and `executionBlocker`. Never infer a stronger support claim from the page design or the LLM's familiarity with a provider. Required scenarios are backend-enforced gates; possible scenarios are reported only when actually exercised.
+   - Stop before `trackly_start_apply_run` whenever `executionBlocker` is non-null. `standard` runs use the provider playbook. `guided` runs are allowed only while semantic browser state remains observable, `originPolicy.authorized` is true, and every published stop condition is obeyed. `manual_only` items stop without starting or mutating a run.
+   - If the user requests the next `N` jobs, freeze the deterministic ordered set of exactly `N` job IDs before starting any run. Do not replace, rescore, or expand that approved batch.
+   - For each fixed batch member, preserve an explicit job ID -> application run ID -> browser tab mapping. Complete the full start -> conditional resume preparation/confirmation/verification when an upload control exists -> form completion -> `review_ready` lifecycle for every member. A review-ready run does not block the next member. Never submit any of them.
+6. Call `trackly_start_apply_run` for the selected job or current fixed batch member. Reuse an active run returned by Trackly; never create a replacement run because browser control was interrupted.
+   - Require `run.protocolVersion` to share protocol major 3 with the fetched protocol. A resumed run may retain an older compatible 3.x patch/minor version; preserve that exact run and let the backend bind observations and resume proof to its stored version. Stop on a major mismatch. Compare `run.atsCapability` and `run.originPolicy` with the queue values. Stop and refetch the protocol and queue if support level, execution mode, provider, required scenarios, or authorized origin policy changed between preflight and run creation.
+   - In guided mode, inspect the page before preparing any resume bytes. Confirm the employer, role, HTTPS origin, reachable review path, semantic controls, whether an attachment control exists, and absence of a credential, verification, CAPTCHA, or submit-only wall. A missing file input is not itself a blocker; skip the resume path when the application has no attachment control. Any other failed precondition is an execution blocker, not permission to improvise.
+7. Pass the browser readiness gate before preparing resume bytes:
+   - Use semantic browser control through Codex in-app browser controls, Chrome MCP/extension browser control, or Claude in Chrome.
+   - Prove non-mutating capability: the surface can discover or reclaim every target tab, inspect the DOM, click and select semantic controls, determine whether a file input exists, and read committed field state. When an upload control exists, identify it semantically. Do not upload any file during readiness; a real upload happens only after exact-file confirmation and verification.
+   - Bind each tab to the exact employer, role, ATS, requisition URL, job ID, and run ID. A window position or ephemeral tab number alone is not identity.
+   - Build a value-free browser binding from those normalized keys plus the semantic browser surface and stable controller tab identity. Compute its lowercase SHA-256; never send the raw URL, title, employer, role, or tab text as observation metadata.
+   - After a handoff, context resume, or browser-control interruption, reclaim and re-verify every mapped tab before continuing.
+   - Report `observationType: browser_ready` for the current run with `scenarioCode: browser_reclaim`, the allowed `browserSurface`, `committed: true`, and that `browserBindingHash`. Do not call `trackly_prepare_resume` until this same-run attestation succeeds. Accessibility may provide an independent verification signal, but coordinate-only clicking is forbidden for form completion.
+   - If the semantic browser bridge is unavailable, preserve every existing run and tab mapping, record the blocker when possible, and stop before any upload or form mutation.
+8. If and only if the application offers or requires a resume attachment, call `trackly_prepare_resume` with that exact application run ID, browser surface, and browser binding hash. If hosted MCP reports it unavailable, tell the user that local Trackly MCP or manual upload is required. If no attachment control exists, skip steps 8–11 and do not report `resume_upload` as exercised.
+9. Preserve the user’s filename returned by `trackly_prepare_resume`. Internal cache identifiers belong only in private parent directories and must never appear in the employer-facing upload filename.
+10. Before any upload, let the user inspect the exact prepared file returned by `trackly_prepare_resume`:
    - Prefer an inline visual preview. Otherwise open the exact local file in Quick Look or Preview.app.
    - Show a compact proof block with source (`Trackly default resume`), exact local path, user-facing filename, file size, SHA-256 fingerprint, application run, and expiration.
-   - Ask for explicit confirmation to use that resume. Bind confirmation to the exact SHA-256 and current application run; a different hash or run requires new confirmation.
+   - Ask for explicit confirmation to use that resume. Bind confirmation to the exact SHA-256 and current application run. For an explicitly approved batch of `N` runs, the user may authorize the same confirmed SHA-256 only for the frozen job/run/tab set; still show and verify each member's exact path, size, hash, run ID, and expiration. Stop if any hash differs, a run is missing, or a run falls outside the frozen batch. Outside that batch, a different hash or run requires new confirmation.
    - Always provide `confirmation.verification.exactLocalPath` so the user can independently verify the file. Never describe the prepared cache path as the original upload source.
    - If an original local source path is known from the current session, identify it separately. Do not store original device paths in Trackly.
    - A generic profile page is not proof of the prepared file. Use an app or web deep link only when the current protocol supplies an authenticated exact-resume viewer tied to the same SHA-256.
    - If no exact preview method works, stop and ask the user to inspect the file manually.
-10. After the user confirms and immediately before attachment, call local `trackly_verify_prepared_resume` with the confirmed run ID, confirmation ID, exact path, SHA-256, size, and expiration. Continue only when it returns `verified: true` for exactly those values. The verifier validates the signed prepare-issued proof, recomputes the file hash, and locks it read-only. If it is unavailable, expired, missing, or mismatched, stop; prepare and visually confirm a fresh copy or require manual upload. Never send a local path or fingerprint to the hosted verifier.
+11. After the user confirms and immediately before attachment, call local `trackly_verify_prepared_resume` with the confirmed run ID, confirmation ID, exact path, SHA-256, size, and expiration. Continue only when it returns `verified: true` for exactly those values. The verifier validates the signed prepare-issued proof, recomputes the file hash, and locks it read-only. If it is unavailable, expired, missing, or mismatched, stop; prepare and visually confirm a fresh copy or require manual upload. Never send a local path or fingerprint to the hosted verifier.
 
 ## Resume after maintenance
 
@@ -54,35 +74,43 @@ If any REST or MCP tool returns canonical `maintenance_mode` (or the legacy `pla
 
 ## Fill the form
 
-Read [references/ats-playbook.md](references/ats-playbook.md) for the detected ATS and [references/form-integrity.md](references/form-integrity.md) before interacting with fields.
+Read [references/ats-playbook.md](references/ats-playbook.md) for the detected ATS, [references/form-integrity.md](references/form-integrity.md), and [references/scenario-coverage.md](references/scenario-coverage.md) before interacting with fields.
 
 Follow this order:
 
-1. Open the application in the controlled browser context and confirm the employer, role, ATS host, and HTTPS URL.
+1. Open the application in the controlled browser context and confirm the employer, role, ATS host, and HTTPS URL. Before entering private data, parse and normalize the URL, then require the exact origin to equal an `originPolicy.authorizedOrigins` entry or the normalized hostname to satisfy `host === allowedDomain` or `host.endsWith("." + allowedDomain)` for an allowed ATS suffix or verified company domain. Never use substring, display-text, logo, or suffix-without-a-dot matching. For a vendor-hosted ATS, execute the backend-owned declarative `originPolicy.tenantRule` exactly, including its extraction, exact-host-depth, locale, percent-decoding, normalization, and fail-closed semantics, then require the normalized result to equal `originPolicy.verifiedAtsTenant`; never invent or reinterpret a strategy token. Revalidate both origin and tenant after every redirect and apply the same policy to every iframe that receives private data. Stop on any unmatched origin or tenant, malformed percent encoding, missing rule, or rule shape the client cannot execute exactly.
 2. Inspect the whole form and identify required fields, semantic controls, consent controls, document inputs, and multi-step sections.
-3. Only after the exact-hash visual confirmation and a successful immediate pre-attach `trackly_verify_prepared_resume` check, upload the prepared resume before autofill when parsing may overwrite contact fields. Do not change the file between verification and attachment. Verify that the filename chip exactly matches the prepared resume’s user-facing filename and contains no internal cache identifier. Stop and replace the attachment if it does not.
+3. When an attachment control exists, only after the exact-hash visual confirmation and a successful immediate pre-attach `trackly_verify_prepared_resume` check, upload the prepared resume before autofill when parsing may overwrite contact fields. Do not change the file between verification and attachment. Verify that the filename chip exactly matches the prepared resume’s user-facing filename and contains no internal cache identifier. Stop and replace the attachment if it does not. When no attachment control exists, skip resume preparation and upload without treating that absence as an error.
 4. Fill typed fields from the resolved Trackly profile. Clear parser-filled data when the canonical state is intentionally blank.
-5. Use real UI clicks for React/native selects, radios, and checkboxes. After every selection, verify the committed value and disappearance of the required-field error.
+5. Use real UI clicks for React/native selects, radios, and checkboxes. Resolve boolean values by their exact semantic label (`true` to Yes, `false` to No), never by option order, index, proximity, or a stale prior selection. After every selection, compare the committed value with the canonical Trackly value. If the field is required or had a validation error before selection, verify that the required-field error disappeared. An optional control with no validation error passes when its committed value is correct. Treat any value mismatch or applicable stale error as a failed field and correct it before continuing.
 6. Recheck email and phone through both browser DOM state and macOS accessibility state. Require exact values and reject duplicate/concatenated values.
 7. Complete known optional fields, education, links, relocation, and source answers. Do not silently omit canonical answers.
+   - Treat partial dates as unknown at the missing precision. If Trackly has only a year but the ATS requires a month, ask once and sync the complete date before selecting either control. Never accept an ATS-selected current/default month or infer an education month.
 8. Use the canonical `consent.background_check_if_advanced` field only when the form explicitly asks for consent to a background check if the candidate advances. If it is unknown, ask before selecting it and save the answer at the user's chosen scope. Never infer it from privacy, demographic, recruiting-data, general application, criminal-record, or professional-reference consent. Treat the latter two as separate unknown consent questions unless the current profile schema supplies their own canonical fields.
-9. Run the full integrity gate, including the final consent checkbox, every visible error, all steps, and any correction banner.
+9. For a free-text application response, read [references/application-writing.md](references/application-writing.md). Calibrate from the user's Trackly writing fields, use only supported profile and role facts, and run the built-in voice and anti-slop gate before entering the response. Do not require a separate writing or humanizer skill.
+10. Run the full integrity gate, including the final consent checkbox, every visible error, all steps, and any correction banner.
 
-When the user corrects an answer, immediately save the appropriate scope with `trackly_update_application_profile` and report only a redacted mechanics observation through `trackly_report_apply_observation`. Never promote one user’s value into a global default.
+When the user corrects an answer, immediately save the appropriate scope with `trackly_update_application_profile` and report only a redacted mechanics observation through `trackly_report_apply_observation`. Never promote one user’s value into a global default. For `generic_web_form`, never save provider-scoped answers; use company scope for form-specific answers.
+
+For every run, track only scenarios actually exercised. Attest `browser_reclaim` once with the same-run `observationType: browser_ready`, exact binding hash, browser surface, and `metadata.committed: true`; do not send a duplicate `scenario_coverage` row for it. Before `review_ready`, report every other exercised scenario with `observationType: scenario_coverage`, the stable scenario code, browser surface, `metadata.committed: true` for `passed` or `corrected`, and whether the tab was resumed after handoff. Every required scenario must have the corresponding same-run committed evidence. If any required scenario is missing, uncommitted, or blocked, record the run as `blocked` instead of `review_ready`. Never include answer values or page text. Include the actual scenario coverage in the final handoff; do not claim unobserved coverage.
 
 ## Review handoff
 
-Call `trackly_record_application_outcome` with `review_ready`, then provide the review block defined in [references/review-handoff.md](references/review-handoff.md). Keep the browser on the final review state and stop.
+Call `trackly_record_application_outcome` with `review_ready`, then provide the review block defined in [references/review-handoff.md](references/review-handoff.md). For a single run, keep the browser on the final review state and stop. For a frozen batch, preserve the current review-ready tab and continue the same lifecycle for the next mapped batch member; stop only after every frozen member is review-ready, then provide one review block per run. Never submit any member. End with job ID -> run ID -> browser tab -> ATS -> status plus the actual scenario coverage for each run.
 
 After the user submits manually:
 
 - If a success page is visible, record `submitted` with a short non-sensitive confirmation signal.
 - If the user explicitly confirms submission, record `submitted` with `user_confirmed`.
 - If neither exists, do not move the job to applied.
+- Treat a contradictory ATS response such as “already applied” as provisional until the exact requisition URL settles. Do not click Submit again. Preserve the page, confirm the job/requisition identifier is unchanged, and re-read the final route state after the UI and network activity settle. A later explicit success state on that same requisition overrides the provisional error and must be recorded as `submitted`; otherwise record the run as blocked without marking the job applied.
 
 ## Support boundary
 
-- Greenhouse: fully supported.
-- Ashby and Lever: best effort; stop if the integrity gate cannot observe committed state.
-- Other ATS platforms: stop and explain that the current protocol does not support them.
+- Treat the current protocol's `atsCapabilities` as authoritative on every run. Do not hardcode or remember a provider's level from an earlier session.
+- `full` means the deterministic Trackly fixtures and live beta cover the advertised mechanics. It never permits submission or bypassing an integrity failure.
+- `best_effort` means use the named playbook and stop if browser and accessibility state disagree.
+- `guided` means the provider or employer-hosted page may be completed only through observable semantic controls. Obey every published stop condition; stop on login credentials, OTP/email verification, CAPTCHA/human verification, unexpected origin/employer, submit-only navigation, or unobservable committed state.
+- `blocked` / `manual_only` means do not start or mutate an application. LinkedIn-hosted applications are manual-only. If Trackly already stores a separate external application URL, evaluate that stored URL as its own ATS/origin; do not request or invent a URL override that the run cannot bind.
+- Unknown employer forms use the protocol's `unknownAtsFallback` only when the queue supplies an authorized, verified company-domain origin policy. An unmatched or unverified HTTPS page is manual-only, not guided, and is never promoted to `full` by the agent.
 - Launch support: Codex and Claude Code on macOS with browser control and computer use available.

package/skills/trackly-apply/references/application-writing.md

@@ -0,0 +1,36 @@
+# Application writing integrity
+
+Use this reference for free-text questions such as "Why this company?", motivation, or experience summaries.
+
+## Calibrate once
+
+- Read `writing.voice_sample` and `writing.style_instructions` from the resolved Trackly profile.
+- Offer both optional fields during profile setup, but never block an application run when they are unknown. If a free-text question appears before the user has set them, ask once before drafting and synchronize the answer. Let the user decline a voice sample, choose intentionally blank style instructions, or continue with the plain default style for the current run.
+- Treat the sample and preferences as private user data. Never copy them into the public skill, logs, observations, or another user's defaults.
+- A separate humanizer or writing skill may be used when available, but it is optional. This gate remains authoritative and self-contained.
+
+## Draft from evidence
+
+1. Answer the exact question using only canonical profile facts, resume evidence, and specific facts visible in the job posting.
+2. Lead with the concrete overlap between the user's experience and the role. Avoid generic company praise or unsupported enthusiasm.
+3. Prefer one or two specific proofs over a broad inventory of strengths. Never invent an achievement, employer, skill, or motivation.
+4. Keep the response proportionate to the form. Short questions should receive short answers.
+
+## Match the user's voice
+
+- Match the sample's register, sentence length, paragraph breaks, first-person usage, punctuation, and level of informality.
+- Honor explicit style instructions over generic defaults.
+- Preserve readable quirks and personality. Do not polish every sentence into the same formal register.
+- When no sample is available, default to plain first-person language, short paragraphs, and concrete evidence.
+
+## Anti-slop gate
+
+Before entering the response:
+
+1. Remove generic praise, inflated claims, vague transitions, boilerplate conclusions, and chatbot phrases.
+2. Rewrite `not just X, but Y`, ornamental rule-of-three lists, and dangling `-ing` clauses unless the user's sample clearly uses them naturally.
+3. Use no em dash by default. Use one only when the user's sample or saved instructions show that punctuation is part of their voice.
+4. Vary sentence length and structure. Avoid a sequence of equally sized, equally formal sentences.
+5. Prefer active verbs, concrete nouns, real numbers, and named examples already supported by the profile.
+6. Read the answer aloud. If it sounds like a press release, generic cover letter, or assistant response, rewrite it.
+7. When a voice sample exists, compare the final response with it for rhythm and register. When the sample was declined or remains unknown for the current run, use the saved style instructions or plain default instead. In every case, confirm each factual claim again.

package/skills/trackly-apply/references/ats-playbook.md

@@ -21,8 +21,31 @@
 - Best effort: stop when a required or semantic control cannot pass the integrity gate.
 - A Lever confirmation/thank-you page is a valid submission signal.
 
-## Unsupported or verification state
+## Guided enterprise ATS
 
-- Do not improvise on unsupported ATS platforms.
-- Pause for OTP, email verification, CAPTCHA, or other human verification. Never read or store the code as a profile answer.
+This group includes Workday, Oracle Recruiting/Taleo, SAP SuccessFactors, iCIMS, Phenom, Eightfold, Jibe, and Avature when the current protocol marks them `guided`.
+
+- Expect account or login steps, multi-page state, custom comboboxes, employer-hosted shells, embedded frames, and resume parsing.
+- Before uploading, confirm there is a semantic path from the current page to review that does not require the agent to enter credentials, solve verification, or cross to an unexpected origin.
+- Reclaim and revalidate the exact requisition after every page transition. Recheck prior-step values when the page exposes them.
+- Stop immediately when committed state is hidden, the only next control submits the application, or an authentication/verification wall appears.
+
+## Guided mid-market ATS
+
+This group includes SmartRecruiters, Workable, BambooHR, Recruitee, Jobvite, Teamtailor, Comeet, Rippling, Gem, JazzHR, Breezy HR, Freshteam, Personio, Pinpoint, Zoho Recruit, Gusto, HiBob, Paylocity, and ADP when the current protocol marks them `guided`. YC Work at a Startup is currently `manual_only` because its shared job URL does not expose a company tenant that Trackly can verify.
+
+- Expect a mixture of native controls, custom widgets, employer subdomains, embedded frames, shared profile data, and optional resume parsing.
+- Match the live HTTPS origin, employer, role, and requisition before entering private data.
+- Use the same committed-state and required-error gate as Greenhouse. Familiar-looking controls do not lower the evidence requirement.
+
+## Unknown employer-hosted form
+
+- Use only when the protocol resolves the run to `generic_web_form` in guided mode and supplies `originPolicy.authorized: true` with `verification: verified_employer_domain`.
+- Inventory every step, origin transition, control type, required error, file input, and review/submit boundary before any upload.
+- Never claim provider support from visual similarity. Stop if any critical control cannot be observed semantically.
+
+## Manual-only or verification state
+
+- Do not automate LinkedIn-hosted applications. If Trackly already stores a separate external application URL, evaluate that stored URL under its own backend-issued ATS and origin policy; otherwise let the user complete the LinkedIn form manually.
+- Pause for login credentials, OTP, email verification, CAPTCHA, or other human verification. Never read or store credentials or a verification code as a profile answer.
 - Report closed/inactive postings as blockers; do not dismiss the saved job unless the user requests it.

package/skills/trackly-apply/references/form-integrity.md

@@ -2,13 +2,32 @@
 
 Run this gate after each semantic selection and again across the entire form before review.
 
+## Browser-control continuity
+
+- If the semantic browser bridge becomes unavailable, stop before the next form mutation. Coordinate-only computer use is not a safe substitute for semantic field control.
+- Preserve the current run and job mapping. After control returns, reclaim and re-verify the tab against the exact employer, role, ATS, requisition URL, job ID, and run ID.
+- Reinspect the DOM and committed control state after every handoff, context resume, navigation, or rerender. Do not assume a stale snapshot or tab handle still identifies the same application.
+- Prepare resume bytes only after semantic tab discovery, inspection, selection, committed-state capability, and a semantic determination that an attachment control exists. A form without a file input skips the resume path; it is not blocked. Do not perform a readiness upload.
+
+## Page and website-type inventory
+
+- Before entering private data on a guided or unknown form, enumerate the current HTTPS origin, every visible step, any iframe origins, all file inputs, and the control that advances toward review. Require every data-receiving origin to match the backend-supplied run `originPolicy`; page text, logos, and employer names are not origin proof.
+- Distinguish `Next`, `Continue`, `Save`, `Review`, and `Submit` by accessible name and observed behavior. If the only way to reveal the next state is a submit-like mutation, stop for manual review.
+- Treat navigation to a different origin as a new trust boundary. Reconfirm employer, role, and requisition, then parse and normalize the redirected URL. An exact origin may equal an `authorizedOrigins` entry; hostname policies match only when `host === allowedDomain` or `host.endsWith("." + allowedDomain)`. Never accept substring, display-text, or `notexample.com` / `example.com.evil.test` lookalikes. On a vendor-hosted ATS, the shared origin is insufficient: execute the backend-owned declarative `originPolicy.tenantRule` exactly after every redirect or data-receiving iframe change, including extraction, exact host depth, optional locale, percent decoding, normalization, and every fail-closed condition. Compare the normalized result to `originPolicy.verifiedAtsTenant`. Never guess the meaning of an opaque strategy token. Unmatched redirects, tenants, malformed encoding, missing or unexecutable rules, and iframe origins are manual-only.
+- Treat an authentication wall as a user handoff. Never enter, retrieve, store, or infer credentials.
+
 ## Semantic controls
 
 - Open React comboboxes and click the exact list option. Do not inject a value or rely on displayed input text.
 - Click native select options, radio labels, and checkboxes through the UI.
-- After selection, verify the selected/checked state from the control, dispatch-completed page state, and visible label.
-- Verify that the control’s required error is absent. A visible value beside “This field is required” is a failed field.
+- Map booleans semantically: canonical `true` must commit the visible Yes-equivalent and canonical `false` the visible No-equivalent. Never choose a boolean option by index, DOM order, keyboard offset, proximity, or previous control state.
+- After selection, verify the selected/checked state from the control, dispatch-completed page state, and visible label. Compare the normalized committed value to the canonical Trackly value; presence alone is insufficient.
+- If the committed value is the semantic opposite of the canonical value, stop the sweep, correct the field through a fresh real UI selection, and report a redacted integrity observation.
+- For a required control or a control that had a validation error before selection, verify that the error is absent afterward. A visible value beside “This field is required” is a failed field. An optional control that never had a validation error passes when its committed value is correct.
 - If a stale error remains, reopen and reselect the control. Use non-submitting validation only when the ATS provides it.
+- For custom comboboxes, verify the selected option through at least one committed semantic signal (`aria-selected`, hidden form value, selected-value chip, or a framework state reflected in the control) plus the visible label. Typed or displayed text alone is not a committed selection.
+- For native selects, verify the selected option's `value` and visible label after the `change` event settles.
+- For radios and checkboxes, verify the input's checked state and its exact associated label. A decorative checkmark is not sufficient.
 
 ## Contact-field integrity
 
@@ -27,3 +46,10 @@ Run this gate after each semantic selection and again across the entire form bef
 6. Confirm the Submit button is present but do not click it.
 
 If any field’s committed state cannot be observed, fail the gate and explain which field needs manual review.
+
+## Submission-state reconciliation
+
+- Never retry Submit after a contradictory or duplicate-application response.
+- Treat “already applied” and similar banners as provisional until the current ATS route finishes settling.
+- Confirm the employer, role, and exact requisition identifier are unchanged, then re-read the final state from that same URL.
+- An explicit success state on the exact requisition is authoritative and may be recorded as submitted. Without success or explicit user confirmation, record blocked and leave the job out of Applied.

package/skills/trackly-apply/references/review-handoff.md

@@ -19,6 +19,7 @@ Education:
 EEO / consent choices:
 Custom answers:
 Integrity sweep: pass/fail
+Actual scenario coverage:
 Items requiring your attention:
 
 Please review the live form and click Submit manually.

package/skills/trackly-apply/references/scenario-coverage.md

@@ -0,0 +1,36 @@
+# Actual scenario coverage
+
+Record only the mechanics exercised on the current application run. Coverage is evidence for improving the reusable harness, not a place for profile values, answers, page text, contact data, or employer-confidential content.
+
+## Observation shape
+
+For each exercised scenario, call `trackly_report_apply_observation` with:
+
+- `runId`: the exact Trackly Apply run.
+- `provider`: the normalized ATS.
+- `fieldLabel`: a generic mechanics label such as `Run scenario coverage`; never copy private page text.
+- `observationType`: `scenario_coverage`.
+- `resolutionCode`: `passed` or `corrected`. A blocked scenario is not scenario-coverage evidence; record the Apply run as `blocked` and optionally report a redacted `integrity_failure` observation.
+- `metadata.scenarioCode`: one stable code from the list below.
+- `metadata.browserSurface`: the semantic browser surface used, such as `codex_in_app`, `chrome_extension`, or `claude_in_chrome`.
+- `metadata.committed`: `true` only after the scenario's actual committed state is observed. Every `passed` or `corrected` scenario requires `true`.
+- `metadata.resumedAfterHandoff`: whether that run's tab had to be reclaimed after a handoff or browser-control interruption.
+
+`browser_reclaim` is the exception to the observation shape above: attest it once with `observationType: browser_ready`, `metadata.scenarioCode: browser_reclaim`, `metadata.browserSurface`, `metadata.browserBindingHash`, and `metadata.committed: true`. Do not send a duplicate `scenario_coverage` row for browser reclaim.
+
+## Stable scenario codes
+
+- `browser_reclaim`: exact job/run/tab binding was discovered or reclaimed and verified.
+- `resume_upload`: the verified exact resume was attached and the employer-facing filename matched.
+- `resume_parser_recheck`: contact or profile fields were rechecked after resume parsing or autofill.
+- `semantic_boolean_commit`: a Yes/No control was selected and verified by semantic value.
+- `custom_select_commit`: a React or native select committed the intended canonical value.
+- `multi_step_navigation`: the form crossed one or more steps and earlier state was reverified.
+- `free_text_voice`: a free-text answer passed the saved-voice and factual-integrity gate.
+- `required_error_sweep`: every required field and visible error surface was checked.
+- `final_consent`: the final certification, acknowledgement, or consent control was verified.
+- `handoff_reclaim`: the browser tab was reclaimed after a context or control handoff.
+
+## Final reporting
+
+List scenario codes separately for every run. Do not report a code because the ATS commonly has that behavior; report it only when it actually occurred and was observed on that run. A visible value is not proof of committed state. When committed state cannot be verified, omit passed/corrected coverage for that scenario and record the run as blocked.