job-application-agent 3.7.0 → 3.7.2

package/job-application-agent/tests/outreach-round.test.mjs

@@ -0,0 +1,489 @@
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+import { fileURLToPath } from 'node:url';
+
+import { deliveryProjection } from '../scripts/application-accounting.mjs';
+import { assessment, handoff } from './fixtures/outreach.mjs';
+import {
+  OUTREACH_ROUND_CHANNEL,
+  companyCountKey,
+  confirmOutreachTowardRound,
+  invalidatedOutreachIds,
+  loadSentVerifiedOutreach,
+  projectOutreachRoundCounts,
+  resolveOutreachRoundId,
+  sentVerifiedFromOutreachItems,
+} from '../scripts/outreach-round.mjs';
+
+const script = fileURLToPath(new URL('../scripts/job-application.mjs', import.meta.url));
+
+function application(roundId, company = 'Example') {
+  return {
+    id: `app-${company.toLowerCase().replace(/[^a-z0-9]+/g, '-')}`,
+    company,
+    role: 'Staff Product Engineer',
+    url: `https://jobs.fixture.example/${company.toLowerCase().replace(/[^a-z0-9]+/g, '-')}`,
+    employerJobId: `example:${company}`,
+    source: 'ashby',
+    discoverySource: 'linkedin',
+    applicationChannel: 'ashby',
+    roundId,
+    score: 86,
+    status: 'submitted',
+    submittedAt: '2026-09-14T10:00:00.000Z',
+    approval: 'STANDING AUTHORIZATION',
+    answers: {},
+  };
+}
+
+function verifiedItem(id, company) {
+  return {
+    id,
+    delivery: 'sent-verified',
+    content: { assessment: { company: { name: company }, role: 'Staff Product Engineer' } },
+  };
+}
+
+test('sent-verified outreach increments a round when no apply exists', () => {
+  const delivery = deliveryProjection([], []);
+  const counts = projectOutreachRoundCounts({
+    applications: [],
+    delivery,
+    roundEvents: [{ type: 'submission-confirmed', roundId: 'round-1', outreachId: 'noon', channel: OUTREACH_ROUND_CHANNEL, company: 'Noon' }],
+    sentVerified: sentVerifiedFromOutreachItems([verifiedItem('noon', 'Noon')]),
+    roundId: 'round-1',
+  });
+  assert.equal(counts.applyConfirmationCount, 0);
+  assert.equal(counts.outreachConfirmationCount, 1);
+  assert.equal(counts.confirmedCount, 1);
+});
+
+test('apply plus outreach at the same company counts once', () => {
+  const applications = [application('round-1', 'Tricog')];
+  const delivery = deliveryProjection(applications, []);
+  const counts = projectOutreachRoundCounts({
+    applications,
+    delivery,
+    roundEvents: [{ type: 'submission-confirmed', roundId: 'round-1', outreachId: 'tricog', channel: OUTREACH_ROUND_CHANNEL, company: 'Tricog' }],
+    sentVerified: sentVerifiedFromOutreachItems([verifiedItem('tricog', 'Tricog')]),
+    roundId: 'round-1',
+  });
+  assert.equal(counts.applyConfirmationCount, 1);
+  assert.equal(counts.outreachConfirmationCount, 0);
+  assert.equal(counts.confirmedCount, 1);
+});
+
+test('cleared outreach still counts from the durable confirmation company', () => {
+  const counts = projectOutreachRoundCounts({
+    applications: [],
+    delivery: deliveryProjection([], []),
+    roundEvents: [{ type: 'submission-confirmed', roundId: 'round-1', outreachId: 'noon', channel: OUTREACH_ROUND_CHANNEL, company: 'Noon' }],
+    sentVerified: sentVerifiedFromOutreachItems([{
+      id: 'noon',
+      delivery: 'sent-verified',
+      cleared: true,
+      content: { assessment: { company: { name: 'Noon' }, role: 'Staff Product Engineer' } },
+    }]),
+    roundId: 'round-1',
+  });
+  assert.equal(counts.applyConfirmationCount, 0);
+  assert.equal(counts.outreachConfirmationCount, 1);
+  assert.equal(counts.confirmedCount, 1);
+});
+
+test('linked company names share one count key', () => {
+  assert.equal(companyCountKey('Made Card'), companyCountKey('MadeCard'));
+  const applications = [application('round-1', 'MadeCard')];
+  const delivery = deliveryProjection(applications, []);
+  const counts = projectOutreachRoundCounts({
+    applications,
+    delivery,
+    roundEvents: [{ type: 'submission-confirmed', roundId: 'round-1', outreachId: 'made', channel: OUTREACH_ROUND_CHANNEL, company: 'Made Card' }],
+    sentVerified: sentVerifiedFromOutreachItems([verifiedItem('made', 'Made Card')]),
+    roundId: 'round-1',
+  });
+  assert.equal(counts.applyConfirmationCount, 1);
+  assert.equal(counts.outreachConfirmationCount, 0);
+  assert.equal(counts.confirmedCount, 1);
+});
+
+test('explicit confirm cannot reassign an attached outreach to another round', () => {
+  assert.throws(() => resolveOutreachRoundId([
+    { type: 'started', roundId: 'round-a', requestedCount: 30, occurredAt: '2026-09-14T10:00:00.000Z' },
+    { type: 'submission-confirmed', roundId: 'round-a', outreachId: 'noon', channel: OUTREACH_ROUND_CHANNEL, company: 'Noon' },
+    { type: 'started', roundId: 'round-b', requestedCount: 30, occurredAt: '2026-09-14T11:00:00.000Z' },
+  ], { outreachId: 'noon', roundId: 'round-b' }), /already attached to another round/);
+});
+
+test('apply-only still increments without outreach', () => {
+  const applications = [application('round-1', 'MadeCard')];
+  const delivery = deliveryProjection(applications, []);
+  const counts = projectOutreachRoundCounts({
+    applications,
+    delivery,
+    roundEvents: [],
+    sentVerified: [],
+    roundId: 'round-1',
+  });
+  assert.equal(counts.applyConfirmationCount, 1);
+  assert.equal(counts.outreachConfirmationCount, 0);
+  assert.equal(counts.confirmedCount, 1);
+});
+
+async function fixture(t, label) {
+  const directory = await mkdtemp(join(tmpdir(), `outreach-round-${label}-`));
+  t.after(() => rm(directory, { recursive: true, force: true }));
+  await writeFile(join(directory, 'telemetry.json'), JSON.stringify({
+    version: 1,
+    enabled: false,
+    disclosed: true,
+    graceConsumed: true,
+    installationEventPending: false,
+  }));
+  const env = {
+    ...process.env,
+    JOB_APPLICATION_AGENT_STATE_DIR: directory,
+    JOB_APPLICATION_AGENT_CLOUD_CONFIG: join(directory, 'cloud-config.json'),
+    JOB_APPLICATION_AGENT_SOURCE_COMMUNITY_URL: 'http://127.0.0.1:9',
+  };
+  const cli = (args, input) => JSON.parse(execFileSync(process.execPath, [script, ...args], {
+    env,
+    encoding: 'utf8',
+    ...(input === undefined ? {} : { input: JSON.stringify(input) }),
+  }));
+  return { directory, env, cli };
+}
+
+function recordVerifiedOutreach(cli, { id, company, domain }) {
+  cli(['outreach', 'policy', 'enable', '--stdin'], { operationId: `enable-${id}`, timezone: 'Asia/Kolkata' });
+  cli(['outreach', 'assess', '--stdin'], assessment(id, {
+    operationId: `assess-${id}`,
+    company: { name: company, domain, aliases: [] },
+    recipient: { account: `https://www.linkedin.com/in/${id}-recruiter`, aliases: [] },
+  }));
+  cli(['outreach', 'draft', '--stdin'], {
+    operationId: `draft-${id}`,
+    id,
+    text: 'Your product engineering role fits my experience. Would a brief conversation be useful?',
+    claimRefs: ['experience'],
+    purpose: 'initial',
+  });
+  const recheckedAt = new Date().toISOString();
+  cli(['outreach', 'handoff', '--stdin'], handoff({
+    operationId: `handoff-${id}`,
+    id,
+    recheckedAt,
+    history: { kind: 'user-reported', noPriorPitch: true, checkedAt: recheckedAt },
+  }));
+  const occurredAt = new Date().toISOString();
+  return cli(['outreach', 'record', '--stdin'], {
+    operationId: `sent-${id}`,
+    id,
+    attemptId: `handoff-${id}`,
+    type: 'sent-verified',
+    occurredAt,
+    evidence: 'Visible sent message in the conversation.',
+    messageRef: `visible-message-${id}`,
+  });
+}
+
+test('CLI sent-verified outreach increments the active round', async (t) => {
+  const { cli } = await fixture(t, 'outreach-only');
+  const { roundId } = cli(['round', 'start', '--stdin'], { requestedCount: 30 });
+  const recorded = recordVerifiedOutreach(cli, { id: 'noon', company: 'Noon', domain: 'noon.com' });
+  assert.equal(recorded.delivery, 'sent-verified');
+  assert.equal(recorded.roundConfirmation.counted, true);
+  assert.equal(recorded.roundConfirmation.roundId, roundId);
+  const status = cli(['round', 'status', roundId]);
+  assert.equal(status.applyConfirmationCount, 0);
+  assert.equal(status.outreachConfirmationCount, 1);
+  assert.equal(status.confirmedCount, 1);
+  assert.equal(status.effectiveSubmissionCount, 0);
+  const again = cli(['round', 'confirm', '--stdin'], { roundId, outreachId: 'noon' });
+  assert.equal(again.confirmations[0].reason, 'already-recorded');
+  assert.equal(again.confirmedCount, 1);
+});
+
+test('CLI apply plus outreach for the same company counts once', async (t) => {
+  const { cli } = await fixture(t, 'apply-and-outreach');
+  const { roundId } = cli(['round', 'start', '--stdin'], { requestedCount: 30 });
+  cli(['ledger', 'add', '--stdin'], application(roundId, 'Tricog'));
+  const recorded = recordVerifiedOutreach(cli, { id: 'tricog', company: 'Tricog', domain: 'tricog.com' });
+  assert.equal(recorded.roundConfirmation.counted, false);
+  assert.equal(recorded.roundConfirmation.reason, 'already-applied');
+  const status = cli(['round', 'status', roundId]);
+  assert.equal(status.applyConfirmationCount, 1);
+  assert.equal(status.outreachConfirmationCount, 0);
+  assert.equal(status.confirmedCount, 1);
+  assert.equal(status.effectiveSubmissionCount, 1);
+});
+
+test('CLI apply-only still increments the round', async (t) => {
+  const { cli } = await fixture(t, 'apply-only');
+  const { roundId } = cli(['round', 'start', '--stdin'], { requestedCount: 30 });
+  cli(['ledger', 'add', '--stdin'], application(roundId, 'MadeCard'));
+  const status = cli(['round', 'status', roundId]);
+  assert.equal(status.applyConfirmationCount, 1);
+  assert.equal(status.outreachConfirmationCount, 0);
+  assert.equal(status.confirmedCount, 1);
+  assert.equal(status.effectiveSubmissionCount, 1);
+});
+
+test('later progression records do not auto-attach a historical send', async (t) => {
+  const { cli } = await fixture(t, 'reply-does-not-count');
+  const recorded = recordVerifiedOutreach(cli, { id: 'noon', company: 'Noon', domain: 'noon.com' });
+  assert.equal(recorded.roundConfirmation.counted, false);
+  assert.equal(recorded.roundConfirmation.reason, 'no-active-round');
+  const { roundId } = cli(['round', 'start', '--stdin'], { requestedCount: 30 });
+  const reply = cli(['outreach', 'record', '--stdin'], {
+    operationId: 'reply-noon',
+    id: 'noon',
+    type: 'replied',
+    occurredAt: new Date().toISOString(),
+    evidence: 'Recruiter replied in the conversation.',
+    replyTone: 'neutral',
+  });
+  assert.equal(reply.delivery, 'sent-verified');
+  assert.equal(reply.roundConfirmation, undefined);
+  const status = cli(['round', 'status', roundId]);
+  assert.equal(status.outreachConfirmationCount, 0);
+  assert.equal(status.confirmedCount, 0);
+});
+
+test('batch confirm validates every ID before committing any', async (t) => {
+  const { cli } = await fixture(t, 'batch-validate');
+  recordVerifiedOutreach(cli, { id: 'noon', company: 'Noon', domain: 'noon.com' });
+  const { roundId } = cli(['round', 'start', '--stdin'], { requestedCount: 30 });
+  assert.throws(
+    () => cli(['round', 'confirm', '--stdin'], { roundId, outreachIds: ['noon', 'missing'] }),
+    /not sent-verified/,
+  );
+  const status = cli(['round', 'status', roundId]);
+  assert.equal(status.outreachConfirmationCount, 0);
+  assert.equal(status.confirmedCount, 0);
+});
+
+test('CLI delivery correction drops confirmedCount after a counted send', async (t) => {
+  const { cli } = await fixture(t, 'delivery-correction');
+  const { roundId } = cli(['round', 'start', '--stdin'], { requestedCount: 30 });
+  recordVerifiedOutreach(cli, { id: 'noon', company: 'Noon', domain: 'noon.com' });
+  assert.equal(cli(['round', 'status', roundId]).confirmedCount, 1);
+  cli(['outreach', 'record', '--stdin'], {
+    operationId: 'correct-noon',
+    id: 'noon',
+    attemptId: 'handoff-noon',
+    type: 'not-sent',
+    occurredAt: new Date().toISOString(),
+    evidence: 'Visible conversation shows the message was not sent.',
+    supersedes: ['sent-noon'],
+  });
+  const after = cli(['round', 'status', roundId]);
+  assert.equal(after.confirmedCount, 0);
+  assert.equal(after.outreachConfirmationCount, 0);
+});
+
+test('sent-verified confirm then clear leaves confirmedCount unchanged', async (t) => {
+  const { cli } = await fixture(t, 'clear-keeps-count');
+  const { roundId } = cli(['round', 'start', '--stdin'], { requestedCount: 30 });
+  const recorded = recordVerifiedOutreach(cli, { id: 'noon', company: 'Noon', domain: 'noon.com' });
+  assert.equal(recorded.roundConfirmation.counted, true);
+  const before = cli(['round', 'status', roundId]);
+  assert.equal(before.confirmedCount, 1);
+  assert.equal(before.outreachConfirmationCount, 1);
+  cli(['outreach', 'clear', '--stdin'], { operationId: 'clear-noon', ids: ['noon'] });
+  const after = cli(['round', 'status', roundId]);
+  assert.equal(after.confirmedCount, before.confirmedCount);
+  assert.equal(after.outreachConfirmationCount, 1);
+  assert.equal(after.applyConfirmationCount, 0);
+});
+
+test('explicit confirm rejects moving an attached outreach to another round', async (t) => {
+  const { cli } = await fixture(t, 'no-reassign');
+  const first = cli(['round', 'start', '--stdin'], { requestedCount: 30 });
+  recordVerifiedOutreach(cli, { id: 'noon', company: 'Noon', domain: 'noon.com' });
+  const second = cli(['round', 'start', '--stdin'], { requestedCount: 30 });
+  assert.throws(
+    () => cli(['round', 'confirm', '--stdin'], { roundId: second.roundId, outreachId: 'noon' }),
+    /already attached to another round/,
+  );
+  assert.equal(cli(['round', 'status', first.roundId]).confirmedCount, 1);
+  assert.equal(cli(['round', 'status', second.roundId]).confirmedCount, 0);
+});
+
+test('auto-attach reconciles authenticated cloud rounds before choosing a destination', async (t) => {
+  const directory = await mkdtemp(join(tmpdir(), 'outreach-round-reconcile-'));
+  t.after(() => rm(directory, { recursive: true, force: true }));
+  const started = { type: 'started', roundId: 'cloud-round', requestedCount: 30, occurredAt: '2026-09-14T10:00:00.000Z' };
+  const reconcileCalls = [];
+  const cloudClient = {
+    configured: async () => true,
+    status: async () => ({ configured: true, capabilities: ['outreach-tracking-v1'] }),
+    request: async () => ({ json: async () => ({ items: [verifiedItem('noon', 'Noon')] }) }),
+    reconcile: async (options) => {
+      reconcileCalls.push(options);
+      await writeFile(join(directory, 'rounds.ndjson'), `${JSON.stringify(started)}\n`);
+    },
+    appendRecord: async () => {},
+  };
+  const result = await confirmOutreachTowardRound({
+    directory,
+    outreachId: 'noon',
+    cloudClient,
+    occurredAt: '2026-09-14T11:00:00.000Z',
+  });
+  assert.deepEqual(reconcileCalls, [{ dryRun: false, provenance: 'outreach-round-attach', streams: ['rounds'] }]);
+  assert.equal(result.counted, true);
+  assert.equal(result.roundId, 'cloud-round');
+  assert.equal(result.company, 'Noon');
+});
+
+test('unmigrated outreach backend is an empty verified set', async (t) => {
+  const directory = await mkdtemp(join(tmpdir(), 'outreach-round-unmigrated-'));
+  t.after(() => rm(directory, { recursive: true, force: true }));
+  const missingCapability = await loadSentVerifiedOutreach(directory, {
+    configured: async () => true,
+    status: async () => ({ configured: true, capabilities: ['application-accounting-v1'] }),
+    request: async () => {
+      throw new Error('Cloud state request failed (409): Outreach backend migration required');
+    },
+  });
+  assert.deepEqual(missingCapability, []);
+  const migrationConflict = await loadSentVerifiedOutreach(directory, {
+    configured: async () => true,
+    status: async () => ({ configured: true, capabilities: ['application-accounting-v1', 'outreach-tracking-v1'] }),
+    request: async () => {
+      throw new Error('Cloud state request failed (409): Outreach backend migration required');
+    },
+  });
+  assert.deepEqual(migrationConflict, []);
+});
+
+test('local outreach read failures stay visible to round status', async (t) => {
+  const directory = await mkdtemp(join(tmpdir(), 'outreach-round-locked-'));
+  t.after(() => rm(directory, { recursive: true, force: true }));
+  await writeFile(join(directory, 'outreach.lock'), 'stale-lock');
+  await assert.rejects(
+    () => loadSentVerifiedOutreach(directory, { configured: async () => false }),
+    /Outreach store is unavailable/,
+  );
+});
+
+test('delivery correction invalidates a counted confirmation; clear does not', () => {
+  const confirmation = { type: 'submission-confirmed', roundId: 'round-1', outreachId: 'noon', channel: OUTREACH_ROUND_CHANNEL, company: 'Noon' };
+  const failed = {
+    id: 'noon',
+    delivery: 'failed',
+    cleared: false,
+    attempts: [{ id: 'handoff-noon', purpose: 'initial', delivery: 'failed' }],
+    content: { assessment: { company: { name: 'Noon' }, role: 'Staff Product Engineer' } },
+  };
+  const failedCounts = projectOutreachRoundCounts({
+    applications: [],
+    delivery: deliveryProjection([], []),
+    roundEvents: [confirmation],
+    sentVerified: sentVerifiedFromOutreachItems([failed]),
+    invalidatedIds: invalidatedOutreachIds([failed]),
+    roundId: 'round-1',
+  });
+  assert.equal(failedCounts.outreachConfirmationCount, 0);
+  assert.equal(failedCounts.confirmedCount, 0);
+
+  const cleared = {
+    id: 'noon',
+    delivery: 'sent-verified',
+    cleared: true,
+    attempts: [{ id: 'handoff-noon', purpose: 'initial', delivery: 'sent-verified' }],
+    content: { assessment: { company: { name: 'Noon' }, role: 'Staff Product Engineer' } },
+  };
+  const clearedCounts = projectOutreachRoundCounts({
+    applications: [],
+    delivery: deliveryProjection([], []),
+    roundEvents: [confirmation],
+    sentVerified: sentVerifiedFromOutreachItems([cleared]),
+    invalidatedIds: invalidatedOutreachIds([cleared]),
+    roundId: 'round-1',
+  });
+  assert.equal(clearedCounts.outreachConfirmationCount, 1);
+  assert.equal(clearedCounts.confirmedCount, 1);
+});
+
+test('attached company identity stays on the confirmation event', () => {
+  const applications = [application('round-1', 'Acme')];
+  const delivery = deliveryProjection(applications, []);
+  const renamed = verifiedItem('acme', 'Acme Holdings');
+  const counts = projectOutreachRoundCounts({
+    applications,
+    delivery,
+    roundEvents: [{ type: 'submission-confirmed', roundId: 'round-1', outreachId: 'acme', channel: OUTREACH_ROUND_CHANNEL, company: 'Acme' }],
+    sentVerified: sentVerifiedFromOutreachItems([renamed]),
+    invalidatedIds: invalidatedOutreachIds([renamed]),
+    roundId: 'round-1',
+  });
+  assert.equal(counts.applyConfirmationCount, 1);
+  assert.equal(counts.outreachConfirmationCount, 0);
+  assert.equal(counts.confirmedCount, 1);
+});
+
+test('non-ASCII company names keep distinct count keys', () => {
+  assert.equal(companyCountKey('Made Card'), companyCountKey('MadeCard'));
+  assert.notEqual(companyCountKey('ソニー'), '');
+  assert.notEqual(companyCountKey('トヨタ'), '');
+  assert.notEqual(companyCountKey('ソニー'), companyCountKey('トヨタ'));
+});
+
+test('an earlier sent-verified attempt still qualifies after a later pending follow-up', () => {
+  const item = {
+    id: 'noon',
+    delivery: 'pending-handoff',
+    attempts: [
+      { id: 'handoff-noon', purpose: 'initial', delivery: 'sent-verified' },
+      { id: 'follow-noon', purpose: 'follow-up', delivery: 'pending-handoff' },
+    ],
+    content: { assessment: { company: { name: 'Noon' }, role: 'Staff Product Engineer' } },
+  };
+  const verified = sentVerifiedFromOutreachItems([item]);
+  assert.equal(verified.length, 1);
+  assert.equal(verified[0].id, 'noon');
+});
+
+test('confirm refuses a cached outreach snapshot when cloud is unavailable', async (t) => {
+  const directory = await mkdtemp(join(tmpdir(), 'outreach-round-no-cache-confirm-'));
+  t.after(() => rm(directory, { recursive: true, force: true }));
+  await writeFile(join(directory, 'rounds.ndjson'), `${JSON.stringify({ type: 'started', roundId: 'round-1', requestedCount: 30, occurredAt: '2026-09-14T10:00:00.000Z' })}\n`);
+  await writeFile(join(directory, 'outreach-cloud-cache.json'), JSON.stringify({
+    snapshot: { items: [verifiedItem('noon', 'Noon')] },
+  }));
+  const cloudClient = {
+    configured: async () => true,
+    status: async () => ({ configured: true, capabilities: ['outreach-tracking-v1'] }),
+    request: async () => {
+      throw new Error('Cloud state unavailable: network down');
+    },
+    reconcile: async () => {
+      throw new Error('Cloud state unavailable: network down');
+    },
+    appendRecord: async () => {
+      throw new Error('should not append from cache');
+    },
+  };
+  await assert.rejects(
+    () => confirmOutreachTowardRound({ directory, outreachId: 'noon', cloudClient }),
+    /authoritative state/,
+  );
+  const cachedStatus = await loadSentVerifiedOutreach(directory, cloudClient, { allowCache: true });
+  assert.equal(cachedStatus.length, 1);
+});
+
+test('round attachment failure does not disguise a committed send', async (t) => {
+  const { directory, cli } = await fixture(t, 'attachment-failed');
+  const { roundId } = cli(['round', 'start', '--stdin'], { requestedCount: 30 });
+  await writeFile(join(directory, 'rounds.ndjson'), `${JSON.stringify({ type: 'started', roundId, requestedCount: 30, occurredAt: '2026-09-14T10:00:00.000Z' })}\nnot-json\n`);
+  const recorded = recordVerifiedOutreach(cli, { id: 'noon', company: 'Noon', domain: 'noon.com' });
+  assert.equal(recorded.delivery, 'sent-verified');
+  assert.equal(recorded.roundConfirmation.counted, false);
+  assert.equal(recorded.roundConfirmation.reason, 'attachment-failed');
+});

package/job-application-agent/tests/skill-contract.test.mjs

@@ -43,6 +43,25 @@ test('documents durable autonomy, resumable rounds, attention and friction contr
   assert.match(agentBox, /DISPLAY=:99/);
 });
 
+test('documents flexible ledger check lookup as a separate process from outcome', async () => {
+  const skill = await readFile(new URL('../SKILL.md', import.meta.url), 'utf8');
+  const marketplaceSkill = await readFile(new URL('../../skills/job-application-agent/SKILL.md', import.meta.url), 'utf8');
+  const schemas = await readFile(new URL('../references/SCHEMAS.md', import.meta.url), 'utf8');
+
+  for (const copy of [skill, marketplaceSkill]) {
+    assert.match(copy, /two separate CLI processes/);
+    assert.match(copy, /company\+role/);
+    assert.match(copy, /possible duplicate/);
+    assert.match(copy, /never treat it as a hard already-applied/);
+    assert.match(copy, /look up the row with `ledger check` first/);
+    assert.match(copy, /pass the returned `match\.id` to `ledger outcome`/);
+    assert.match(copy, /If `match\.id` is absent, stop and ask/);
+  }
+  assert.match(schemas, /any one identifier set/);
+  assert.match(schemas, /Never promote a company\+role match to a hard already-applied/);
+  assert.match(schemas, /ledger add` still requires a real job URL/);
+});
+
 test('documents Free.ai as optional LLM assist only', async () => {
   const skill = await readFile(new URL('../SKILL.md', import.meta.url), 'utf8');
   const freeAi = await readFile(new URL('../references/FREE_AI.md', import.meta.url), 'utf8');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "job-application-agent",
-  "version": "3.7.0",
+  "version": "3.7.2",
   "description": "A privacy-first Agent Skill and CLI for evidence-based job discovery, application completion, and outcome tracking.",
   "license": "MIT",
   "type": "module",
@@ -44,7 +44,7 @@
     "check:native-artifacts": "node scripts/ci/validate-native-artifacts.mjs",
     "privacy-audit": "node --test job-application-agent/tests/privacy-audit.test.mjs job-application-agent/tests/outreach-cli.test.mjs",
     "smoke:package": "node scripts/smoke-package.mjs",
-    "check": "node --check job-application-agent/scripts/job-application.mjs && node --check job-application-agent/scripts/attention-runner-poll.mjs && node --check job-application-agent/scripts/attention-resume-submit.mjs && node --check job-application-agent/scripts/session-binding.mjs && node --check job-application-agent/scripts/novnc-display-guard.mjs && node --check job-application-agent/scripts/ats/submit-adapters.mjs && node --check job-application-agent/scripts/cloud-state-client.mjs && node --check job-application-agent/scripts/secret-store.mjs && node --check job-application-agent/scripts/source-community-client.mjs && node --check job-application-agent/scripts/source-community-schema.mjs && node --check job-application-agent/scripts/telemetry-client.mjs && node --check job-application-agent/scripts/telemetry-schema.mjs && node --check job-application-agent/scripts/version.mjs && node --check telemetry-worker/src/worker.mjs && node --check telemetry-worker/src/public-stats.mjs && node --check telemetry-worker/public/dashboard.js && node --check installer/src/cli.mjs && node --check installer/src/installer.mjs && node --check installer/src/runner.mjs && node --check installer/src/scheduler.mjs && node --check scripts/ci/classify-paths.mjs && node --check scripts/ci/validate-native-artifacts.mjs && node --check bin/job-application-agent.mjs && node --check state-worker/src/worker.mjs && node --check state-worker/src/backup.mjs && node --check state-worker/src/cli.mjs && node --check state-worker/bin/sync.mjs && node --check job-application-agent/scripts/application-accounting.mjs && node --check job-application-agent/scripts/outreach-domain.mjs && node --check job-application-agent/scripts/outreach-store.mjs && node --check job-application-agent/scripts/outreach-cli.mjs && node --check state-worker/src/outreach.mjs && node --check job-application-agent/scripts/ats/answer-inject.mjs && node --check job-application-agent/scripts/attention-questions.mjs && node --check job-application-agent/scripts/captcha-vendor.mjs",
+    "check": "node --check job-application-agent/scripts/job-application.mjs && node --check job-application-agent/scripts/attention-runner-poll.mjs && node --check job-application-agent/scripts/attention-resume-submit.mjs && node --check job-application-agent/scripts/session-binding.mjs && node --check job-application-agent/scripts/novnc-display-guard.mjs && node --check job-application-agent/scripts/ats/submit-adapters.mjs && node --check job-application-agent/scripts/cloud-state-client.mjs && node --check job-application-agent/scripts/secret-store.mjs && node --check job-application-agent/scripts/source-community-client.mjs && node --check job-application-agent/scripts/source-community-schema.mjs && node --check job-application-agent/scripts/telemetry-client.mjs && node --check job-application-agent/scripts/telemetry-schema.mjs && node --check job-application-agent/scripts/version.mjs && node --check telemetry-worker/src/worker.mjs && node --check telemetry-worker/src/public-stats.mjs && node --check telemetry-worker/public/dashboard.js && node --check installer/src/cli.mjs && node --check installer/src/installer.mjs && node --check installer/src/runner.mjs && node --check installer/src/scheduler.mjs && node --check scripts/ci/classify-paths.mjs && node --check scripts/ci/validate-native-artifacts.mjs && node --check bin/job-application-agent.mjs && node --check state-worker/src/worker.mjs && node --check state-worker/src/backup.mjs && node --check state-worker/src/cli.mjs && node --check state-worker/bin/sync.mjs && node --check job-application-agent/scripts/application-accounting.mjs && node --check job-application-agent/scripts/outreach-domain.mjs && node --check job-application-agent/scripts/outreach-store.mjs && node --check job-application-agent/scripts/outreach-cli.mjs && node --check job-application-agent/scripts/outreach-round.mjs && node --check state-worker/src/outreach.mjs && node --check job-application-agent/scripts/ats/answer-inject.mjs && node --check job-application-agent/scripts/attention-questions.mjs && node --check job-application-agent/scripts/captcha-vendor.mjs",
     "prepack": "npm run check && npm test && npm run privacy-audit"
   },
   "engines": {