trackly-cli 0.14.2 → 0.15.0

package/contracts/trackly-apply-contract-history.json

@@ -17,5 +17,11 @@
   },
   "3.7.1": {
     "contractSha256": "0eb582fcac72804347c5da53d214a67908f657f600536db7b42167350bb3f3ab"
+  },
+  "3.7.2": {
+    "contractSha256": "058dc698ff1b0722f48b9f244773c0f09286046540609c31f001fe8604b06093"
+  },
+  "3.7.3": {
+    "contractSha256": "d37e7ec0a17d3dba399f12dd7281c51536ca92bbb21125ca09288d1678f34c14"
   }
 }

package/contracts/trackly-apply-tools.json

@@ -1,5 +1,5 @@
 {
-  "contractVersion": "3.7.1",
+  "contractVersion": "3.7.3",
   "constants": {
     "applyExecutionMaxTarget": 20,
     "applyScenarioCodes": ["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", "critical_contact_integrity", "manual_submit_boundary", "job_identity_match"],
@@ -23,11 +23,16 @@
     "applyUploadStages": ["semantic_control_discovered", "file_chooser_armed", "file_chooser_opened", "set_files_succeeded", "user_facing_filename_committed", "parser_fields_rechecked"],
     "applyUploadFailureCodes": ["upload_capability_unavailable", "upload_stage_missing", "upload_stage_out_of_order", "upload_stage_duplicate", "control_ambiguous", "chooser_timeout", "chooser_open_without_commit", "file_missing", "file_expired", "set_files_failed", "filename_uncommitted", "unexpected_file_navigation", "parser_unsettled", "parser_field_regression"]
   },
+  "toolInputInvariants": {
+    "trackly_get_apply_execution_snapshot": {
+      "officeProjectionMemberIdsMustExistInMemberIds": true
+    }
+  },
   "tools": {
     "trackly_get_apply_queue": "{limit:z.number().int().min(1).max(100).optional(),cursor:z.string().min(1).max(2048).optional()}",
-    "trackly_get_application_profile": "{includeSensitive:z.boolean().optional(),provider:z.string().max(100).optional(),companyId:z.string().max(100).optional(),jurisdiction:iso3166Alpha2Schema.optional()}",
+    "trackly_get_application_profile": "{includeSensitive:z.boolean().optional(),provider:z.string().max(100).optional(),companyId:z.string().max(100).optional(),jurisdiction:iso3166Alpha2Schema.optional(),office:officeScopeSchema.optional()}",
     "trackly_get_profile_onboarding": "{}",
-    "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()}),z.object({key:z.string().min(1).max(200),state:z.enum(['unknown','answered','intentionally_blank','declined']),value:z.any().optional(),scope:z.literal('jurisdiction'),scopeValue:iso3166Alpha2Schema,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(),sensitiveRevocationConfirmToken:z.string().regex(/^[a-f0-9]{64}$/).optional()}",
+    "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()}),z.object({key:z.string().min(1).max(200),state:z.enum(['unknown','answered','intentionally_blank','declined']),value:z.any().optional(),scope:z.literal('jurisdiction'),scopeValue:iso3166Alpha2Schema,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('office'),scopeValue:officeScopeSchema,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(),sensitiveRevocationConfirmToken:z.string().regex(/^[a-f0-9]{64}$/).optional()}",
     "trackly_start_apply_execution": "{mode:z.literal('complete_next_n_accessible'),target:z.number().int().min(1).max(APPLY_EXECUTION_MAX_TARGET),idempotencyKey:z.string().min(16).max(200).regex(SAFE_IDEMPOTENCY_KEY)}",
     "trackly_get_active_apply_execution": "{}",
     "trackly_get_apply_execution": "{executionId:z.number().int().min(1)}",
@@ -35,7 +40,7 @@
     "trackly_recover_exact_apply_members": "{sourceExecutionId:z.number().int().min(1),sourceSnapshotHash:z.string().regex(/^[a-f0-9]{64}$/),candidateIds:z.array(z.number().int().min(1)).min(1).max(APPLY_EXECUTION_MAX_TARGET).refine((values)=>newSet(values).size===values.length,{message:'candidateIdsmustbeunique'}),explicitExactSetConfirmation:z.literal(true),idempotencyKey:z.string().min(16).max(200).regex(SAFE_IDEMPOTENCY_KEY)}",
     "trackly_list_apply_review_handoffs": "{executionId:z.number().int().min(1)}",
     "trackly_claim_apply_review_handoff": "{handoffId:z.number().int().min(1),members:z.array(z.object({memberId:z.number().int().min(1),classification:z.enum(APPLY_HANDOFF_RECONCILIATION_CLASSIFICATION_CODES)}).strict()).min(1).max(APPLY_EXECUTION_MAX_TARGET).refine((values)=>newSet(values.map(({memberId})=>memberId)).size===values.length,{message:'membersmustcontainuniquememberIdvalues'}),idempotencyKey:z.string().min(16).max(200).regex(SAFE_IDEMPOTENCY_KEY)}",
-    "trackly_get_apply_execution_snapshot": "{executionId:z.number().int().min(1),memberIds:z.array(z.number().int().min(1)).min(1).max(APPLY_EXECUTION_MAX_TARGET),profileKeys:z.array(z.string().min(1).max(200)).max(100).optional(),browserSurface:z.enum(APPLY_BROWSER_SURFACES)}",
+    "trackly_get_apply_execution_snapshot": "{executionId:z.number().int().min(1),memberIds:z.array(z.number().int().min(1)).min(1).max(APPLY_EXECUTION_MAX_TARGET).refine((values)=>newSet(values).size===values.length,{message:'memberIdsmustbeunique'}),profileKeys:z.array(z.string().min(1).max(200)).max(100).refine((values)=>newSet(values).size===values.length,{message:'profileKeysmustbeunique'}).optional(),officeProjections:z.array(z.object({memberId:z.number().int().min(1),office:officeScopeSchema,profileKeys:z.array(z.string().min(1).max(200)).min(1).max(100).refine((values)=>newSet(values).size===values.length,{message:'officeprofileKeysmustbeunique'})}).strict()).max(APPLY_EXECUTION_MAX_TARGET).refine((values)=>newSet(values.map(({memberId})=>memberId)).size===values.length,{message:'officeProjectionsmustcontainuniquememberIdvalues'}).optional(),browserSurface:z.enum(APPLY_BROWSER_SURFACES)}",
     "trackly_resume_parked_apply_member": "{executionId:z.number().int().min(1),memberId:z.number().int().min(1),expectedRevision:z.number().int().min(1),browserSurface:z.enum(APPLY_BROWSER_SURFACES),explicitUserResume:z.literal(true),idempotencyKey:z.string().min(16).max(200).regex(SAFE_IDEMPOTENCY_KEY)}",
     "trackly_approve_apply_execution_resume": "{executionId:z.number().int().min(1),expectedRevision:z.number().int().min(1),originalSnapshotHash:z.string().regex(/^[a-f0-9]{64}$/),profileRevision:z.number().int().min(1),resumeId:z.number().int().min(1),resumeSha256:z.string().regex(/^[a-f0-9]{64}$/),resumeFilename:z.string().min(1).max(255),resumeSizeBytes:z.number().int().min(1),expiresAt:z.string().datetime(),idempotencyKey:z.string().min(16).max(200).regex(SAFE_IDEMPOTENCY_KEY)}",
     "trackly_advance_apply_execution": "{executionId:z.number().int().min(1),expectedRevision:z.number().int().min(1),browserSurface:z.enum(APPLY_BROWSER_SURFACES),idempotencyKey:z.string().min(16).max(200).regex(SAFE_IDEMPOTENCY_KEY)}",

package/lib/agent.js

@@ -8,7 +8,7 @@ const { spawnSync } = require('node:child_process');
 const { apiRequest, downloadFile, getConfigPaths, hasAuth, maintenanceOutput } = require('./client');
 const { version: PACKAGE_VERSION } = require('../package.json');
 const { contractVersion: MCP_CONTRACT_VERSION } = require('../contracts/trackly-apply-tools.json');
-const SKILL_VERSION = '4.5.0';
+const SKILL_VERSION = '4.6.0';
 const CLI_USER_AGENT = `trackly-cli/${PACKAGE_VERSION}`;
 const MCP_USER_AGENT = `trackly-mcp/${PACKAGE_VERSION}`;
 

package/mcp/apply-tools.js

@@ -40,6 +40,7 @@ const SAFE_IDEMPOTENCY_KEY = /^[\x20-\x7e]+$/;
 const iso3166Alpha2Schema = z.string().regex(/^[A-Za-z]{2}$/).refine(isIso3166Alpha2, {
   message: 'Expected an ISO 3166-1 alpha-2 country code',
 });
+const officeScopeSchema = z.string().regex(/^[1-9]\d*:[A-Za-z0-9][A-Za-z0-9._-]{0,150}$/);
 const opaqueTabIdSchema = z.union([
   z.number().int().safe(),
   z.string().min(1).max(512).refine((value) => value.trim().length > 0, {
@@ -262,7 +263,7 @@ const startApplyRunSchema = z.object({
   }
 });
 
-const APPLY_RELIABILITY_PROMPT = 'Protocol 3.6 / skill 4.5.0 reliability gate: recover active work first. After full local context loss, list recoverable executions, show only stable job identity, obtain explicit confirmation of the exact candidate set, and call exact-member recovery without substitutions. Treat recovered tab presence, form state, and mutation authority as three separate facts; reacquire a fresh browser binding and inspection epoch before mutation. Before resolving broad submission statements, list active review handoffs for the execution; use only an explicit receipt or the sole returned active receipt, classify every member as detected, user_confirmed, unresolved, or contradictory, and claim that exact handoff before writing outcomes. Use provider-specific positive success evidence; an unchanged URL or title is never negative evidence. Validate an exact expected browser keep set locally before finalization. For resume uploads, negotiate the browser surface capabilities, identify the semantic control, arm the chooser before clicking, attach the immediately verified file, prove the user-facing filename committed, and recheck parser-modified fields. Use compact snapshots and server-provided mutability. Preserve user-edited and unknown non-empty fields. Never reopen parked work without explicit user resumption. Never click Submit.';
+const APPLY_RELIABILITY_PROMPT = 'Protocol 3.6 / skill 4.6.0 reliability gate: recover active work first. After full local context loss, list recoverable executions, show only stable job identity, obtain explicit confirmation of the exact candidate set, and call exact-member recovery without substitutions. Treat recovered tab presence, form state, and mutation authority as three separate facts; reacquire a fresh browser binding and inspection epoch before mutation. Before resolving broad submission statements, list active review handoffs for the execution; use only an explicit receipt or the sole returned active receipt, classify every member as detected, user_confirmed, unresolved, or contradictory, and claim that exact handoff before writing outcomes. Use provider-specific positive success evidence; an unchanged URL or title is never negative evidence. Validate an exact expected browser keep set locally before finalization. For resume uploads, negotiate the browser surface capabilities, identify the semantic control, arm the chooser before clicking, attach the immediately verified file, prove the user-facing filename committed, and recheck parser-modified fields. Use compact snapshots and server-provided mutability. Preserve user-edited and unknown non-empty fields. Never reopen parked work without explicit user resumption. Never click Submit.';
 
 function registerApplyTools(
   server,
@@ -311,13 +312,19 @@ function registerApplyTools(
       provider: z.string().max(100).optional(),
       companyId: z.string().max(100).optional(),
       jurisdiction: iso3166Alpha2Schema.optional(),
+      office: officeScopeSchema.optional(),
     },
-    wrapTool(async ({ includeSensitive, provider, companyId, jurisdiction }) => {
+    wrapTool(async ({ includeSensitive, provider, companyId, jurisdiction, office }) => {
+      const normalizedCompanyId = companyId?.trim();
+      if (office && (!normalizedCompanyId || !office.startsWith(`${normalizedCompanyId}:`))) {
+        throw new Error('Office scope must match the requested companyId');
+      }
       const qs = new URLSearchParams();
       if (includeSensitive) qs.set('includeSensitive', 'true');
       if (provider) qs.set('provider', provider);
-      if (companyId) qs.set('companyId', companyId);
+      if (normalizedCompanyId) qs.set('companyId', normalizedCompanyId);
       if (jurisdiction) qs.set('jurisdiction', jurisdiction);
+      if (office) qs.set('office', office);
       return applyApiRequest('GET', `/api/jobscout/application-profile?${qs.toString()}`, null, false, false, MCP_USER_AGENT);
     }, 'Failed to fetch application profile')
   );
@@ -361,6 +368,11 @@ function registerApplyTools(
           value: z.any().optional(), scope: z.literal('jurisdiction'), scopeValue: iso3166Alpha2Schema,
           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('office'), scopeValue: officeScopeSchema,
+          questionLabel: z.string().max(1000).optional(),
+        }),
       ])).max(100).optional(),
       education: z.array(z.object({
         school: z.string().min(1).max(500),
@@ -535,13 +547,36 @@ function registerApplyTools(
     'Fetch a compact, bounded projection for one Apply execution. Request only the current members and profile keys needed for the visible form. The response owns mutability, allowed operations, milestones, lease timing, and progress.',
     {
       executionId: z.number().int().min(1),
-      memberIds: z.array(z.number().int().min(1)).min(1).max(APPLY_EXECUTION_MAX_TARGET),
-      profileKeys: z.array(z.string().min(1).max(200)).max(100).optional(),
+      memberIds: z.array(z.number().int().min(1)).min(1).max(APPLY_EXECUTION_MAX_TARGET)
+        .refine((values) => new Set(values).size === values.length, {
+          message: 'memberIds must be unique',
+        }),
+      profileKeys: z.array(z.string().min(1).max(200)).max(100)
+        .refine((values) => new Set(values).size === values.length, {
+          message: 'profileKeys must be unique',
+        }).optional(),
+      officeProjections: z.array(z.object({
+        memberId: z.number().int().min(1),
+        office: officeScopeSchema,
+        profileKeys: z.array(z.string().min(1).max(200)).min(1).max(100)
+          .refine((values) => new Set(values).size === values.length, {
+            message: 'office profileKeys must be unique',
+          }),
+      }).strict()).max(APPLY_EXECUTION_MAX_TARGET)
+        .refine((values) => new Set(values.map(({ memberId }) => memberId)).size === values.length, {
+          message: 'officeProjections must contain unique memberId values',
+        }).optional(),
       browserSurface: z.enum(APPLY_BROWSER_SURFACES),
     },
-    wrapTool(async ({ executionId, ...body }) => applyControlRequest(
-      'POST', `/api/jobscout/apply/executions/${executionId}/snapshot`, body,
-    ), 'Failed to fetch compact apply execution snapshot')
+    wrapTool(async ({ executionId, ...body }) => {
+      const memberIds = new Set(body.memberIds);
+      if (body.officeProjections?.some(({ memberId }) => !memberIds.has(memberId))) {
+        throw new Error('Every office projection memberId must exist in memberIds.');
+      }
+      return applyControlRequest(
+        'POST', `/api/jobscout/apply/executions/${executionId}/snapshot`, body,
+      );
+    }, 'Failed to fetch compact apply execution snapshot')
   );
 
   server.tool(
@@ -1162,6 +1197,9 @@ function registerApplyTools(
     messages: [{
       role: 'user',
       content: { type: 'text', text: APPLY_RELIABILITY_PROMPT },
+    }, {
+      role: 'user',
+      content: { type: 'text', text: 'Before generating questions or filling controls, run the skill 4.6 deterministic answer resolver. Classify every visible answer as exact_profile, safe_derivation, supported_draft, missing_fact, live_consent, or forbidden_inference; validate the control type; fill only the first three; and ask only currently visible unresolved needs. Treat the current profile revision as reusable authority, never transcript, screenshot, parser, autocomplete, or cached values. Accessible-first is a hard scheduler invariant: park known authentication, account-creation, OTP, and pre-form-CAPTCHA work without starting a draft while an accessible candidate remains.' },
     }, {
       role: 'user',
       content: { type: 'text', text: 'Only active=true identifies resumable execution work. Active=false and preserved=true is terminal read-only reconciliation evidence.' },
@@ -1169,7 +1207,7 @@ function registerApplyTools(
       role: 'user',
       content: {
         type: 'text',
-        text: 'Protocol 3.6.0 reliability gate for new work: require MCP contract 3.7.1 and skill 4.5.0. After complete local context loss, list bounded recovery candidates, obtain explicit confirmation of the exact set, and recover only that set. Treat tab recovery, form-state recovery, and mutation authority as independent. List active handoff receipts for the execution before resolving grouped submission statements; use the named receipt or the sole returned active receipt, classify every member, and claim that receipt before recording outcomes. Validate tab keep sets and resume upload stages locally. Never send raw browser values or click Submit.',
+        text: 'Protocol 3.6.0 reliability gate for new work: require MCP contract 3.7.3 and skill 4.6.0. After complete local context loss, list bounded recovery candidates, obtain explicit confirmation of the exact set, and recover only that set. Treat tab recovery, form-state recovery, and mutation authority as independent. List active handoff receipts for the execution before resolving grouped submission statements; use the named receipt or the sole returned active receipt, classify every member, and claim that receipt before recording outcomes. Validate tab keep sets and resume upload stages locally. Never send raw browser values or click Submit.',
       },
     }, {
       role: 'user',

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "trackly-cli",
-  "version": "0.14.2",
+  "version": "0.15.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "trackly-cli",
-      "version": "0.14.2",
+      "version": "0.15.0",
       "license": "MIT",
       "dependencies": {
         "@modelcontextprotocol/sdk": "1.30.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trackly-cli",
-  "version": "0.14.2",
+  "version": "0.15.0",
   "mcpName": "io.github.trackly-app/trackly",
   "description": "AI job search CLI + hosted MCP server with OAuth. 170K+ jobs, 3,800+ 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.14.2",
+  "version": "0.15.0",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "trackly-cli",
-      "version": "0.14.2",
+      "version": "0.15.0",
       "runtimeHint": "npx",
       "runtimeArguments": [
         {

package/skills/trackly-apply/SKILL.md

@@ -22,12 +22,13 @@ Use Trackly as the source of truth for profile answers, documents, queue decisio
 
 Before selecting or resuming work, read
 [references/batch-orchestration.md](references/batch-orchestration.md) and
-[references/browser-lifecycle.md](references/browser-lifecycle.md). Those
+[references/browser-lifecycle.md](references/browser-lifecycle.md). Before generating an employer-form question packet, also read and run
+[references/answer-resolution.md](references/answer-resolution.md). These
 references define the server-frozen batch, grouped-question, tab-reconciliation,
 and missing-surface recovery contract; they are mandatory even for a one-job batch.
 Read [references/legal-clarifications.md](references/legal-clarifications.md) when a form asks for a legal, regulatory, consent, or employer-relationship decision.
 
-1. Call `trackly_get_apply_protocol`. Skill 4.5.0 requires protocol 3.6.0 or newer for new reliability work. Protocol 3.2 remains valid only for an already-active explicit legacy single run; an already-active explicit 3.2 single run may finish through its legacy path. Preserve the protocol's documented recovery paths for already-active older work. Require `compatibleSkillMajor: 4` and `compatibleSkillMinimumVersion` no newer than this installed skill. Reject an older or incompatible version for new work and report that the backend must finish updating or `trackly agent setup` must update the skill. Protocol 3.2 added exact-origin trust for jobs Trackly ingested directly from employer careers sources; do not recreate the retired ownership-timestamp gate in the client.
+1. Call `trackly_get_apply_protocol`. Skill 4.6.0 requires protocol 3.6.0 or newer for new reliability work. Protocol 3.2 remains valid only for an already-active explicit legacy single run; an already-active explicit 3.2 single run may finish through its legacy path. Preserve the protocol's documented recovery paths for already-active older work. Require `compatibleSkillMajor: 4` and `compatibleSkillMinimumVersion` no newer than this installed skill. Reject an older or incompatible version for new work and report that the backend must finish updating or `trackly agent setup` must update the skill. Protocol 3.2 added exact-origin trust for jobs Trackly ingested directly from employer careers sources; do not recreate the retired ownership-timestamp gate in the client.
 2. Call `trackly_get_profile_onboarding` or fetch both the profile schema and application profile. When present, render `schema.screens` in ascending `order` as one grouped question packet per screen. Within a screen, preserve category `order` and then field `order`; use each field's user-facing `rationale` when the user asks why it is needed. Ask only unknown or confirmation-needed fields and honor `consistencyRules` before submitting profile changes, resolving contradictions with the user instead of guessing. When `schema.screens` is absent on a legacy backend, fall back to the existing category-based onboarding behavior. Treat `completeness.percent` as required onboarding readiness only. Use `coverage.missingReusableKeys` to explain reusable optional gaps, while `coverage.contextualKeys` are intentionally asked only on the relevant employer form. Do not claim that 100% required completeness answers every possible application question.
 3. Save answers with `trackly_update_application_profile`:
    - Use `answered`, `intentionally_blank`, `declined`, or `unknown` exactly.
@@ -48,6 +49,7 @@ Read [references/legal-clarifications.md](references/legal-clarifications.md) wh
    - After full local context loss with no active execution, call `trackly_list_recoverable_apply_executions`. For every distinct returned `jobId`, call `trackly_get_job`, bind that Trackly-owned job record to the returned `candidateId`, and show the user its company, role, requisition identity when available, and source-execution identity; do not identify candidates from chat, tab order, search results, or page copy. A missing or mismatched Trackly job record blocks confirmation. Require explicit confirmation of one exact candidate set, then call `trackly_recover_exact_apply_members` with that source execution, snapshot hash, and only those candidate IDs. Verify `assertedCandidateIds`, `eligibleCandidateIds`, and the eligibility candidate IDs each contain exactly the confirmed set with no duplicates. Never add substitutes, newly saved jobs, or merely similar roles.
    - Exact recovery restores server lineage only. Treat tab restored, form state restored, and mutation authority restored as three independent receipts. Bind every recovered surface with a fresh recovery binding and inspection epoch, revalidate the full form, and preserve every user-edited or unknown non-empty value before any write. Earlier-epoch browser, field, upload, integrity, and submission evidence cannot authorize the recovered form.
    - Every compact snapshot request must contain a non-empty list of only the current member IDs. Never request an empty or inferred all-members projection.
+   - When a visible form asks an office-scoped profile question and the exact employer office is known, request that field only through the matching member's `officeProjections` entry using the canonical `companyId:office-identity` scope. Consume only the returned `memberOfficeProfiles` entry for that same member and exact office; never move an office answer into the global profile map or reuse it for another member, employer, or office. A recovered member may reuse the answer only when Trackly proves its frozen company identity. If a legacy snapshot cannot prove that identity, preserve the form and treat the answer as unknown instead of refilling from chat or current mutable job metadata.
    - Recover every entry in `execution.unresolvedWaves` in ascending `waveOrder`; `currentWave` identifies only the latest scheduling wave, not the complete recovery set.
    - Immediately consume the start response's authoritative `progress` and `nextAction`; do not issue a speculative advance first.
    - When that authoritative `nextAction` requests another wave, call `trackly_advance_apply_execution` with the actual current `browserSurface`, latest execution revision, and a fresh idempotency key.
@@ -71,7 +73,7 @@ Read [references/legal-clarifications.md](references/legal-clarifications.md) wh
    - 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. When the selected job or current fixed batch member has no `runId`, call `trackly_start_apply_run` with the complete `batchId`, `memberId`, `expectedMemberVersion`, `expectedInspectionEpoch`, and `leaseToken` returned by Trackly. This is the sanctioned idempotent lookup for a recovered member whose `runId` is absent; call it with the exact recovered binding and Trackly will reuse the bound active run. When the member already has a `runId`, do not call `trackly_start_apply_run` in this or any subsequent start step: reuse that exact run and bind or recover its browser surface through `trackly_bind_apply_surface` as required. Never create a replacement run because browser control was interrupted.
    - If a bound start returns a transport failure, a non-access HTTP 5xx response, or an error explicitly marked `retryable: true`, preserve the frozen member and browser state. Refetch the active batch, renew its lease, and retry the same complete binding once. Classify the retry response independently with these same rules: route canonical `maintenance_mode` or legacy `planned_maintenance` directly through **Resume after maintenance**; surface controlled-access/request errors marked `retryable: false` and every other HTTP 4xx response unchanged; only a second transport failure, non-access HTTP 5xx response, or explicitly retryable error becomes `backend_run_start_unavailable`. Route maintenance on either attempt without consuming or relabeling the retry, and never relabel a permanent retry response as an outage. For `backend_run_start_unavailable`, continue other members and report a Trackly control-plane failure. Do not call `trackly_checkpoint_apply_batch` for this condition because start failure has not produced the required run ID. The unchanged frozen member is the durable resume point. Never switch that frozen member to an unbound legacy run or blame the employer form.
-   - Require `run.protocolVersion` to be 3.1.0 or newer and to share protocol major 3 with the fetched protocol. A new reliability execution member requires 3.6.0 or newer; already-active older work may use only the recovery path published by its fetched protocol. Never continue a pre-evidence 3.0.x run under skill 4.5.0. Preserve that run instead of starting a replacement, record it `blocked` with a value-free protocol-upgrade reason when possible, and tell the user the saved job can be retried only after the stale run is cleared through Trackly's supported lifecycle. Stop and refetch the protocol and active execution or batch if support level, execution mode, provider, required scenarios, authorized origin policy, member version, or inspection epoch changes after run creation.
+   - Require `run.protocolVersion` to be 3.1.0 or newer and to share protocol major 3 with the fetched protocol. A new reliability execution member requires 3.6.0 or newer; already-active older work may use only the recovery path published by its fetched protocol. Never continue a pre-evidence 3.0.x run under skill 4.6.0. Preserve that run instead of starting a replacement, record it `blocked` with a value-free protocol-upgrade reason when possible, and tell the user the saved job can be retried only after the stale run is cleared through Trackly's supported lifecycle. Stop and refetch the protocol and active execution or batch if support level, execution mode, provider, required scenarios, authorized origin policy, member version, or inspection epoch changes after 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.
@@ -112,7 +114,7 @@ Follow this order:
 1. Open the application in the controlled browser context and confirm the employer, role, ATS host, and HTTPS URL. Before entering private data, require the visible company and role to match the run binding and, when the stored URL exposes one, require the requisition identifier to match. When `job_identity_match` is required, immediately report its value-free committed `scenario_coverage` proof after this check passes; never include company, role, URL, requisition, or page text in the observation. On exact-origin fallback, revalidate the frozen company, role, and available requisition identity after every navigation or redirect and before entering any additional 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. When `verification` is `trackly_employer_source_exact_origin`, accept only the exact listed origin; never convert it into a hostname suffix or carry it across a redirect or iframe origin change. For every other vendor-hosted ATS policy, require both `originPolicy.tenantRule` and `originPolicy.verifiedAtsTenant` to be non-null; stop before private data entry if either is missing. Execute the backend-owned declarative tenant rule 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 required 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. 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. Before writing any non-empty control, apply the local field-ownership gate from [references/form-integrity.md](references/form-integrity.md). Preserve `user_edited` and `unknown_external_change` values byte-for-byte unless the user explicitly requests a rewrite; never let resume parsing, rerendering, recovery, or the final sweep overwrite them.
+4. Run the deterministic resolver from [references/answer-resolution.md](references/answer-resolution.md) against the visible controls, then fill typed fields from the resolved Trackly profile. Every answer must be classified as `exact_profile`, `safe_derivation`, `supported_draft`, `missing_fact`, `live_consent`, or `forbidden_inference` before use. Clear parser-filled data when the canonical state is intentionally blank. Before writing any non-empty control, apply the local field-ownership gate from [references/form-integrity.md](references/form-integrity.md). Preserve `user_edited` and `unknown_external_change` values byte-for-byte unless the user explicitly requests a rewrite; never let resume parsing, rerendering, recovery, or the final sweep overwrite them.
 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 every visible field whose canonical answer is known, including optional fields, previous-employer/title history, education rows and dates, links, relocation, communication preferences, and opportunity source. Before review, compare the live field inventory with the resolved Trackly profile and prove that no known visible answer was silently omitted. Group only genuinely unknown contextual fields into the question packet.

package/skills/trackly-apply/references/answer-compounding.md

@@ -8,14 +8,20 @@ questions and piecemeal profile writes.
 
 1. Collect all newly supplied answers from the current question packet.
 2. Fetch the current profile schema and the smallest relevant profile
-   projection once. Include `provider`, `company`, and `jurisdiction` when that
-   context is known and required. Corporate-family reuse is unavailable until
+   projection once. Include `provider`, `company`, `jurisdiction`, and `office`
+   when that context is known and required. An office scope value is the exact
+   backend company ID plus a stable office identity, for example
+   `42:waltham-ma`; never derive it from a display name alone. Corporate-family reuse is unavailable until
    Trackly has an authoritative company-family registry; never derive a family
    identity from names, logos, page text, parent-company knowledge, or search.
 3. Map each answer to an exposed canonical key and permitted scope. Never call
    a field missing merely because it was absent from the compact execution
    snapshot; contextual fields require a targeted profile fetch.
-4. Classify every answer as exactly one of:
+4. Validate the expected input type before mapping or writing. “Whole number”
+   requires a number, and “Yes or No” requires a boolean. A mismatch remains
+   unresolved and returns to the grouped packet; never coerce a boolean into
+   years, a proficiency label into a language level, or vice versa.
+5. Classify every answer as exactly one of:
    - `saved`: a canonical field exists and this run changed it;
    - `already_matched`: the canonical field already contains the same state and
      value at the resolved scope;
@@ -23,9 +29,13 @@ questions and piecemeal profile writes.
      live schema audit;
    - `run_only_contextual`: the answer is intentionally per-run, such as the
      final truthfulness certification, and must not enter the reusable profile.
-5. Ask scope only when the user's wording and the schema do not determine it.
+6. Ask scope only when the user's wording and the schema do not determine it.
    “Always” means global only for fields whose schema permits global scope.
 
+Compound a reusable gap only when a visible form requires it. Defer optional
+profile gaps that no current visible application needs; do not turn the full
+schema into an onboarding questionnaire.
+
 ## One write and one verification
 
 - Send all `saved` changes in one `trackly_update_application_profile` call
@@ -65,6 +75,10 @@ claim that Trackly learned it.
 
 - Country-specific work authorization:
   `authorization.legally_authorized_by_country` at `jurisdiction` scope.
+- Employer-office commute willingness and cadence:
+  `location.commute_willing`, `location.commute_days_per_week`, and
+  `location.commute_commitment` at exact `office` scope. Never reuse an answer
+  for another office of the same company.
 - Prior interview with the employer:
   `employment.previously_interviewed_at_employer` at `company` scope.
 - Employment, contracting, consulting, temporary work, or similar engagement
@@ -83,6 +97,18 @@ claim that Trackly learned it.
   the backend can prove a match. A write receipt or refetch verifies only the
   company scope and `questionFingerprint`; a redacted, unknown, or absent
   reusable value is expected and must not block truth certification or review.
+- Named applicant privacy-notice routing:
+  `consent.named_applicant_privacy_notice_acknowledgement_policy` is a global
+  routing policy, not consent to unseen text. `acknowledge_named_notice_only`
+  permits only a visible, unbundled named applicant notice; `ask` remains a
+  live question. Marketing, retention, arbitration, background-check,
+  recording, AI, and data-sharing choices stay separate.
+- Interview recording or transcription consent and workplace-policy
+  acknowledgement: use `consent.interview_recording` and
+  `consent.workplace_policy_acknowledgement` only at exact company scope with
+  the current policy question or version as `questionLabel`. Both are
+  `run_only_contextual`: retain the fingerprint for audit, ask again, and never
+  require a reusable returned value during the verification refetch.
 - Consumer hardware, IoT, or retail experience level and supporting summary:
   the two global `employment.consumer_hardware_iot_retail_experience_*` fields.
 - Residential city and EEO sexual orientation remain their existing canonical

package/skills/trackly-apply/references/answer-resolution.md

@@ -0,0 +1,123 @@
+# Deterministic answer resolution
+
+Run this resolver after reading the current application-profile revision and
+inventorying a visible employer form, but before generating that form's
+question packet or writing an answer. Profile onboarding that happens before
+an employer form exists uses the profile schema's field metadata instead.
+This resolver reduces questions without weakening truthfulness.
+
+## Resolution pipeline
+
+For each visible question:
+
+1. Normalize its label, help text, expected input type, choices, employer scope,
+   jurisdiction, and whether it is required.
+2. Map it to one exact current schema key. Do not map by a single keyword.
+3. Resolve one authority class:
+   - `exact_profile`: an answered canonical key with matching scope and type.
+   - `safe_derivation`: a deterministic derivation allowed below.
+   - `supported_draft`: free text whose every factual claim has evidence.
+   - `missing_fact`: no authoritative value exists; ask at point of use.
+   - `live_consent`: a notice, acknowledgement, certification, or choice that
+     must be made against the current form.
+   - `forbidden_inference`: a legal, identity, relationship, or specialized
+     claim that cannot be inferred.
+4. Validate the expected input type before translating or committing a value.
+5. Fill only the first three classes. Put only visible `missing_fact`,
+   `live_consent`, and user-resolvable `forbidden_inference` items in one
+   grouped question packet with expected type and scope.
+
+Keep this value-free local provenance for each resolved control: profile
+revision, schema key, scope, authority class, derivation rule when any,
+expected type, and committed-control receipt. Never send the answer value in
+an observation.
+
+## Source precedence
+
+The current profile revision is the only reusable answer authority. A
+transcript or conversation, screenshot, parser output, browser autocomplete,
+or cached value is never authority. Resume parsing is a suggestion only: it may
+help identify a schema key, but the parser never becomes authority and never
+overwrites an answered profile value or a user-edited control.
+
+Contact details and addresses must resolve from exact current profile keys.
+Verify their live committed state even when the browser initially displays a
+masked or formatted value.
+
+For an ordinary application name, use the canonical first and last name and
+reconcile parser-created casing. A government-ID full legal name is different:
+use it only when the form explicitly asks for a government-ID or legal-document
+name and the dedicated restricted profile field is explicitly answered. Never
+derive it from ordinary name fields.
+
+Employment status outranks legacy employer columns. When status is
+`not_employed`, current company and current title are non-authoritative even if
+legacy values remain populated. For a current-employer control, commit boolean
+No, an exact “Not currently employed” option, or an intentionally blank optional
+text control according to the visible control semantics. Ask only when a
+required control offers no truthful non-employed representation. Answer
+prior-employer questions from
+`employment.most_recent_company` and `employment.most_recent_title`, and leave current-employer
+questions unresolved unless the schema supplies an applicable authoritative
+answer. `student`, `other`, or unknown status fails closed when applicability
+is ambiguous.
+
+## Safe experience derivation
+
+Read the wording semantically:
+
+- A minimum qualification/profile range asks whether experience meets the
+  lower threshold. A profile value of 7 years answers “2–4 years?” as Yes when
+  the choices mean “at least 2 years” or a qualification bracket.
+- An exact bounded band asks whether the value lies inside both bounds. With 7
+  years, “exactly between 2 and 4 years?” is No.
+- An explicit disqualifying maximum is a ceiling. With 7 years, “no more than 4 years?” is No.
+
+Never infer specialized experience from total product-management tenure.
+Financial-infrastructure years, growth-focused software PM years, enterprise
+SaaS PM years, health-tech experience, and named platform/tool experience need
+their own schema keys or an explicit user answer.
+
+Type must match the control. Returning Yes for “financial-infrastructure
+years” is a type mismatch; ask for a whole number. Returning C2 for SQL
+proficiency is a type mismatch when the field expects a proficiency enum.
+English C2 is valid when the English field expects a CEFR level. Never coerce a
+type mismatch into a plausible-looking answer.
+
+## Employer relationships and legal boundaries
+
+A direct prior-employment No may be derived only under the complete-history
+rule in the main skill. It never proves no contractor, affiliate, subsidiary,
+acquisition, family, friendship, referral, or other relationship. Those need
+an exact matching scoped field or a user answer.
+
+Region authorization is separate from country authorization. A region may be
+answered Yes only when it is explicitly present in
+`authorization.legally_authorized_regions`; absence is unknown, never No, and a
+region answer must not be stored under a country jurisdiction.
+
+Commute willingness and days-per-week commitments are employer-office facts,
+not company-wide facts. Resolve them only from an exact `office` scope whose
+identity combines the backend company ID and the specific office; another
+office at the same employer remains unknown.
+
+A named applicant privacy notice may be acknowledged only as the current
+notice policy allows and with its current fingerprint. Marketing, data
+retention, arbitration, background check, and interview recording are separate
+choices. Onsite willingness does not prove that a workplace policy was read or
+accepted. Truthfulness certification is always per-run and never reusable.
+
+## Supported writing
+
+For a useful optional motivation or experience prompt, `supported_draft` means
+fill it when every factual claim is supported. Build from canonical facts and
+evidence claims, state explicit gaps instead of inventing bridge facts, match
+the saved voice rules, lint, commit, and reread. The user's final truth review
+still governs the complete review-ready subset.
+
+Ask the user only for a genuinely new fact, subjective choice, live consent,
+or unsupported claim that the visible application requires. A visible employer
+accuracy checkbox is a live consent resolved before the review-ready
+checkpoint; the separate Trackly truth certification is requested only
+afterward for the exact durable review-ready subset. Defer reusable
+gaps that no current visible form needs.

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

@@ -40,4 +40,11 @@ Before entering the response:
 
 When `writing.optional_question_policy` permits it, answer a strategically useful optional motivation, experience, product, or role-overlap question when every fact is supported. Optional does not mean skip. Leave demographic, consent, legal, compensation, and employer-relationship questions unanswered when their canonical value is unknown. Group those unknowns into the consolidated question packet.
 
+A supported strategically useful optional prompt must not be left blank. Draft
+it from canonical evidence claims, expose any explicit gaps instead of
+inventing bridge facts, match the user's voice, pass deterministic lint, enter
+the committed text, and reread it from the live control. Ask only when a new
+fact or subjective choice is actually required; the final truth review remains
+the user's approval boundary.
+
 Before entering any answer, supply value-free claim fingerprints and evidence-reference codes to the local linter. It returns only a draft hash, length, policy, and violation codes. It never echoes or sends the draft to Trackly.

package/skills/trackly-apply/references/batch-orchestration.md

@@ -116,6 +116,16 @@ With protocol 3.5 or newer and the compact-snapshot capability enabled, prefer `
 
 Every compact snapshot request must contain a non-empty list of current member IDs. Never use an empty member projection as shorthand for all members.
 
+For an office-scoped question visible on one member, add an `officeProjections`
+entry containing only that member ID, its canonical `companyId:office-identity`,
+and the exact office-only keys needed by the form. Read the answer only from the
+matching `memberOfficeProfiles` entry. Never copy it into the shared profile
+projection or reuse it for a sibling member, another office, or another
+employer. Recovery does not weaken this binding: Trackly must prove the
+candidate's frozen company identity through its source lineage. A legacy
+candidate without that immutable identity stays unknown and must be confirmed
+from the visible form/user rather than inferred from current job metadata.
+
 The execution freezes one original recent-first queue snapshot and ordering
 version. Newly saved jobs wait for the next execution. Every continuation is a
 new immutable child batch linked in wave order; never append, replace, reorder,
@@ -300,6 +310,22 @@ evidence cannot satisfy the current gate.
 
 ## First pass
 
+Accessible-first is a hard scheduler invariant. While any accessible candidate remains, a known authentication-gated, account-creation, OTP, or pre-form
+CAPTCHA candidate must not be opened. When access is unknown, perform only a
+minimal non-mutating probe. If a gate appears, never start a draft or enter
+private data: record the typed disposition, park it, and continue accessible
+work. The backend disposition must release its reservation or capacity and
+increment the authoritative `authParked` funnel count before replacement
+scheduling. If that durable transition conflicts, preserve the surface and
+surface the conflict; never invent released capacity locally.
+
+An authoritative already-parked member is not first-pass browser work and
+needs no duplicate disposition. A server access hint is not authoritative: if
+accessible candidates remain, defer that hinted member; after accessible work
+is exhausted, perform the minimal live probe required by the public
+disposition contract. “Process every frozen member” below means every currently
+actionable, non-parked member subject to this deferral rule.
+
 Process every frozen member even when another needs user input:
 
 1. Create or reuse its bound application run.

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

@@ -60,8 +60,11 @@ agent-written fingerprint.
 
 ## Contact-field integrity
 
-- Compare email and phone to the exact Trackly values after resume parsing and autofill.
-- Read both DOM input state and macOS accessibility state.
+- Resolve email, phone, name, and address from exact canonical keys in the current profile revision. Transcript or conversation text, screenshots, parser output, autocomplete, and cached values are never reusable authority.
+- Compare email and phone to the exact Trackly values after resume parsing and autofill. Reconcile parser-altered ordinary name casing to canonical first/last-name casing; never use that rule for a government-ID name.
+- Read both DOM input state and macOS accessibility state. A static HTML `value` attribute is not truth or proof of the live committed control state; require rendered live state, framework/native state, or accessibility state after events settle.
+- For a masked phone control, compare its normalized live digits and country code to the canonical phone rather than requiring identical formatting. Prove an implicit country code from live control metadata, a committed country selector, or framework/native state; ten visible digits alone do not prove it.
+- For address autocomplete, choose the exact offered option and prove that option committed through the control's semantic state; displayed typed text alone is insufficient.
 - Reject duplicate or concatenated values, autofill overlays, placeholder-only text, and values present only in a custom wrapper.
 - Recheck when navigation, resume parsing, or a correction banner rerenders the form.
 - Before review, inventory every email, phone, country-code, and required contact control. Pass `critical_contact_integrity` only when all present canonical values are exact and no required contact field was omitted. A form with no contact control passes only after the whole-form inventory confirms none exists or is required.