job-application-agent 3.7.0 → 3.7.1

package/job-application-agent/SKILL.md

@@ -76,7 +76,7 @@ Check `round status` after the initial discovery pass and before submitting. Pre
 
 1. When private cloud state is configured, run `cloud status`, acquire the application-run lease with `cloud lease-acquire`, and renew it at least every five minutes. A client without the live lease may research and draft but must not submit.
 2. Recheck employer, title, direct domain, posting status, eligibility, and `autoEligible` immediately before submission.
-3. Run `ledger check --stdin` with the internal ledger ID, canonical URL, employer job ID, company, and role when available. Review both requisition duplicate status and same-company history.
+3. Run `ledger check --stdin` with any one identifier set: job URL, internal application id, employer job id plus company, or company+role. Include more identifiers when known. A company+role match is a possible duplicate and returns the stored URL; never treat it as a hard already-applied. Review both requisition duplicate status and same-company history.
 4. Stop on a hard ledger-ID, canonical-URL, employer-job-ID, or requisition duplicate. Treat a same-company/same-role alias as a possible duplicate. Use `duplicateOverride: "NEW REQUISITION CONFIRMED"` only after verifying it is a distinct requisition.
 5. For a genuinely different role at a previously applied company, follow `companyReapply`: proceed automatically only when it returns `eligible-after-cooldown` (15 full days since the latest company application and no recorded outcome). `cooldown-active` and `follow-up-present` require the candidate's explicit approval and `companyReapplyOverride: "CANDIDATE APPROVED EARLY REAPPLICATION"`.
 6. Keep authentication in the existing browser session. Never inspect cookies, local storage, passwords, or session files.
@@ -95,6 +95,7 @@ Check `round status` after the initial discovery pass and before submitting. Pre
 
 - Keep `applications.ndjson` and `outcomes.ndjson` append-only. Never delete or rewrite historical rows.
 - Record outcomes with `ledger outcome --stdin`. Use structured rejection reasons and mark each as `explicit` or `inferred`. Do not treat an inference as a candidate fact.
+- Run `ledger check` and `ledger outcome` as two separate CLI processes. Do not combine them in one invocation. When mail has company and role but no URL or id, look up the row with `ledger check` first; that hit is only a possible duplicate and includes the stored URL and id. Then pass the returned `match.id` to `ledger outcome`. If `match.id` is absent, stop and ask; do not guess among fuzzy company+role hits.
 - After an interview, optionally record `interviewQuality` (`promising`, `viable`, `weak`, or `dead`) and a bounded `failurePoint`. Keep free-form interview notes private.
 - Rely on idempotent outcome recording; identical events do not append rows or emit duplicate telemetry.
 - Audit matched delivery failures with authorized email tools when available; otherwise report delivery not audited and continue. Keep delivery failures separate from hiring rejections.

package/job-application-agent/references/SCHEMAS.md

@@ -81,7 +81,7 @@ Assessment output retains `review`, `ask`, `skip`, and `exclude`, and adds `auto
 
 ## Duplicate check input
 
-Include as many identifiers as are known.
+`ledger check` accepts any one identifier set: job URL, internal application id, employer job id plus company, or company+role. Include more identifiers when known. Company-only, role-only, and empty objects are rejected.
 
 ```json
 {
@@ -93,7 +93,7 @@ Include as many identifiers as are known.
 }
 ```
 
-The check removes fragments and non-job query parameters while retaining recognized job or requisition identifiers. Matching ledger ID, canonical URL, or same-company employer job ID is a hard duplicate. Same company and role without a shared job ID is a possible duplicate.
+The check removes fragments and non-job query parameters while retaining recognized job or requisition identifiers. Matching ledger ID, canonical URL, or same-company employer job ID is a hard duplicate. Same company and role without a shared job ID is a possible duplicate and includes the stored URL. Never promote a company+role match to a hard already-applied. `ledger add` still requires a real job URL.
 
 `ledger check` also returns `companyReapply`. A genuinely different role is `eligible-after-cooldown` only when at least 15 full days have passed since the latest application to that company and no outcome has been recorded for that application. Hard duplicates are never eligible. Same-role matches, `cooldown-active`, and `follow-up-present` remain blocked at `ledger add` unless their exact documented override is present.
 

package/job-application-agent/scripts/job-application.mjs

@@ -208,6 +208,11 @@ function string(value, label, max = 5000) {
   return value.trim();
 }
 
+function optionalPresentString(candidate, key, max) {
+  if (!Object.hasOwn(candidate, key)) return '';
+  return string(candidate[key], `candidate.${key}`, max);
+}
+
 function stringArray(value, label, required = false) {
   if (!Array.isArray(value) || (required && value.length === 0)) throw new Error(`${label} must be ${required ? 'a non-empty' : 'an'} array of strings.`);
   return value.map((item, index) => string(item, `${label}[${index}]`, 300));
@@ -481,6 +486,26 @@ export function validateLedgerEntry(input) {
   return normalized;
 }
 
+export function validateLedgerCheckCandidate(input) {
+  const candidate = object(input, 'candidate');
+  const id = optionalPresentString(candidate, 'id', 180);
+  const url = optionalPresentString(candidate, 'url', 2048);
+  const employerJobId = optionalPresentString(candidate, 'employerJobId', 300);
+  const company = optionalPresentString(candidate, 'company', 300);
+  const role = optionalPresentString(candidate, 'role', 300);
+  if (!url && !id && !(employerJobId && company) && !(company && role)) {
+    throw new Error('ledger check requires at least one identifier set: url, id, employerJobId+company, or company+role.');
+  }
+  if (url) normalizeUrl(url);
+  return {
+    ...(id ? { id } : {}),
+    ...(url ? { url } : {}),
+    ...(employerJobId ? { employerJobId } : {}),
+    ...(company ? { company } : {}),
+    ...(role ? { role } : {}),
+  };
+}
+
 export function validateSubmissionTelemetry(input) {
   if (input == null) return {};
   const value = object(input, 'entry.telemetry');
@@ -519,6 +544,15 @@ function rolesLikelySame(left, right) {
   return shared / Math.min(leftTokens.size, rightTokens.size) >= 0.75;
 }
 
+function latestMatchingEntry(entries, predicate) {
+  const matches = entries.filter(predicate);
+  if (matches.length === 0) return null;
+  return [...matches]
+    .filter((entry) => !Number.isNaN(Date.parse(entry.submittedAt)))
+    .sort((left, right) => Date.parse(right.submittedAt) - Date.parse(left.submittedAt))[0]
+    ?? matches.at(-1);
+}
+
 const canonicalApplicationKey = accountingApplicationKey;
 
 function businessDaysBetween(startValue, endValue) {
@@ -995,21 +1029,28 @@ async function canonicalResumePath() {
 function duplicateResult(entries, candidate, outcomes = [], now = new Date()) {
   const candidateCompany = normalizedText(candidate.company);
   const candidateRole = normalizedText(candidate.role);
-  const candidateUrl = normalizeUrl(candidate.url);
+  const candidateUrl = candidate.url ? normalizeUrl(candidate.url) : null;
   const sameCompanyRole = (entry) => candidateCompany && candidateRole
     && normalizedText(entry.company) === candidateCompany
     && rolesLikelySame(entry.role, candidate.role);
-  const hardId = entries.find((entry) => entry.id === candidate.id);
+  const exactCompanyRole = (entry) => candidateCompany && candidateRole
+    && normalizedText(entry.company) === candidateCompany
+    && normalizedText(entry.role) === candidateRole;
+  const hardId = candidate.id ? entries.find((entry) => entry.id === candidate.id) : null;
   const hardEmployerJobId = entries.find((entry) => candidate.employerJobId && entry.employerJobId
     && normalizedText(entry.company) === candidateCompany
     && entry.employerJobId.toLowerCase() === String(candidate.employerJobId).toLowerCase());
-  const hardUrl = entries.find((entry) => normalizeUrl(entry.url) === candidateUrl);
+  const hardUrl = candidateUrl ? entries.find((entry) => normalizeUrl(entry.url) === candidateUrl) : null;
   const hard = hardId ?? hardEmployerJobId ?? hardUrl;
   const hardReason = hardId ? 'id' : hardEmployerJobId ? 'employer-job-id' : hardUrl ? 'url' : null;
-  const possible = hard ? null : entries.find(sameCompanyRole);
+  const exact = hard ? null : latestMatchingEntry(entries, exactCompanyRole);
+  const fuzzyMatches = hard || exact ? [] : entries.filter(sameCompanyRole);
+  const ambiguousCompanyRole = fuzzyMatches.length > 1;
+  const possible = hard ? null : exact ?? (fuzzyMatches.length === 1 ? fuzzyMatches[0] : null);
   const match = hard ?? possible;
-  const sameCompanyEntries = candidateCompany
-    ? entries.filter((entry) => normalizedText(entry.company) === candidateCompany)
+  const historyCompany = candidateCompany || normalizedText(hard?.company);
+  const sameCompanyEntries = historyCompany
+    ? entries.filter((entry) => normalizedText(entry.company) === historyCompany)
     : [];
   const companyApplications = sameCompanyEntries.slice(-20).map((entry) => ({
       id: entry.id,
@@ -1029,15 +1070,15 @@ function duplicateResult(entries, candidate, outcomes = [], now = new Date()) {
     : false;
   let companyReapplyDecision = 'fresh-company';
   if (hard) companyReapplyDecision = 'hard-duplicate';
-  else if (possible) companyReapplyDecision = 'same-role-review';
+  else if (possible || ambiguousCompanyRole) companyReapplyDecision = 'same-role-review';
   else if (latestCompanyApplication && hasFollowUp) companyReapplyDecision = 'follow-up-present';
   else if (latestCompanyApplication && daysSinceLatest < COMPANY_REAPPLY_COOLDOWN_DAYS) companyReapplyDecision = 'cooldown-active';
   else if (latestCompanyApplication) companyReapplyDecision = 'eligible-after-cooldown';
   return {
     duplicate: Boolean(hard),
-    possibleDuplicate: Boolean(possible),
-    reason: hardReason ?? (possible ? 'company-role' : null),
-    match: match ? { id: match.id, company: match.company, role: match.role, submittedAt: match.submittedAt } : null,
+    possibleDuplicate: Boolean(possible) || ambiguousCompanyRole,
+    reason: hardReason ?? (possible || ambiguousCompanyRole ? 'company-role' : null),
+    match: match ? { id: match.id, company: match.company, role: match.role, submittedAt: match.submittedAt, url: match.url } : null,
     sameCompany: companyApplications.length > 0,
     companyApplications,
     companyReapply: {
@@ -1052,12 +1093,11 @@ function duplicateResult(entries, candidate, outcomes = [], now = new Date()) {
 }
 
 async function ledgerCheck(candidate) {
-  object(candidate, 'candidate');
+  const normalized = validateLedgerCheckCandidate(candidate);
   const dir = await ensureStateDir();
   const entries = await jsonLines(join(dir, 'applications.ndjson'));
   const outcomes = await jsonLines(join(dir, 'outcomes.ndjson'));
-  string(candidate.url, 'candidate.url', 2048);
-  return duplicateResult(entries, candidate, outcomes);
+  return duplicateResult(entries, normalized, outcomes);
 }
 
 async function ledgerAdd(entryInput, duplicateOverride, companyReapplyOverride, cloudIntent = null) {

package/job-application-agent/scripts/version.mjs

@@ -1 +1 @@
-export const SKILL_VERSION = '3.7.0';
+export const SKILL_VERSION = '3.7.1';

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

@@ -7,7 +7,7 @@ import test from 'node:test';
 import { fileURLToPath } from 'node:url';
 import { createServer } from 'node:http';
 
-import { buildReview, commandCategory, durationBucket, migrateProfile, profileStatus, scoreJob, telemetryErrorCode, telemetryJobAssessed, validateLedgerEntry, validateProfile, validateSubmissionTelemetry } from '../scripts/job-application.mjs';
+import { buildReview, commandCategory, durationBucket, migrateProfile, profileStatus, scoreJob, telemetryErrorCode, telemetryJobAssessed, validateLedgerCheckCandidate, validateLedgerEntry, validateProfile, validateSubmissionTelemetry } from '../scripts/job-application.mjs';
 
 const target = {
   name: 'Test Candidate',
@@ -347,6 +347,164 @@ test('warns on same-company role matches and serializes concurrent duplicate sub
   assert.equal(possible.possibleDuplicate, true);
 });
 
+test('accepts any one ledger check identifier set and never hard-matches company+role', () => {
+  assert.deepEqual(validateLedgerCheckCandidate({ url: 'https://jobs.example.com/123' }), { url: 'https://jobs.example.com/123' });
+  assert.deepEqual(validateLedgerCheckCandidate({ id: 'example-role-1' }), { id: 'example-role-1' });
+  assert.deepEqual(validateLedgerCheckCandidate({ employerJobId: 'example:123', company: 'Example' }), {
+    employerJobId: 'example:123', company: 'Example',
+  });
+  assert.deepEqual(validateLedgerCheckCandidate({ company: 'Example', role: 'Senior Product Engineer' }), {
+    company: 'Example', role: 'Senior Product Engineer',
+  });
+  const identifierError = /ledger check requires at least one identifier set: url, id, employerJobId\+company, or company\+role/;
+  assert.throws(() => validateLedgerCheckCandidate({}), identifierError);
+  assert.throws(() => validateLedgerCheckCandidate({ company: 'Example' }), identifierError);
+  assert.throws(() => validateLedgerCheckCandidate({ role: 'Senior Product Engineer' }), identifierError);
+  assert.throws(() => validateLedgerCheckCandidate({ employerJobId: 'example:123' }), identifierError);
+  try {
+    validateLedgerCheckCandidate({});
+  } catch (error) {
+    assert.match(error.message, identifierError);
+    assert.doesNotMatch(error.message, /candidate\.url must/);
+  }
+  assert.throws(() => validateLedgerCheckCandidate({ url: 'not-a-url' }), /Invalid URL|invalid/i);
+  assert.throws(() => validateLedgerCheckCandidate({ id: 'example-role-1', url: 123 }), /candidate\.url must/);
+  assert.throws(() => validateLedgerCheckCandidate({ id: 'example-role-1', url: null }), /candidate\.url must/);
+});
+
+test('looks up ledger rows without requiring a URL on check', async (t) => {
+  const directory = await mkdtemp(join(tmpdir(), 'public-job-agent-check-lookup-'));
+  t.after(() => rm(directory, { recursive: true, force: true }));
+  const script = fileURLToPath(new URL('../scripts/job-application.mjs', import.meta.url));
+  await writeFile(join(directory, 'telemetry.json'), JSON.stringify({ version: 1, enabled: false, disclosed: true, graceConsumed: true, installationEventPending: false }));
+  const storedUrl = 'https://jobs.example.com/123';
+  await writeFile(join(directory, 'applications.ndjson'), `${JSON.stringify({
+    id: 'example-role-1', company: 'Example', role: 'Senior Product Engineer', url: storedUrl, source: 'company', score: 88,
+    status: 'submitted', submittedAt: '2026-01-15T10:00:00Z', approval: 'STANDING AUTHORIZATION', answers: {}, employerJobId: 'example:123',
+  })}\n`);
+  const env = isolatedCliEnv(directory);
+
+  const byUrl = JSON.parse(execFileSync(process.execPath, [script, 'ledger', 'check', '--stdin'], {
+    input: JSON.stringify({ url: 'https://jobs.example.com/123?utm_source=board' }), env, encoding: 'utf8',
+  }));
+  assert.equal(byUrl.duplicate, true);
+  assert.equal(byUrl.reason, 'url');
+
+  const byId = JSON.parse(execFileSync(process.execPath, [script, 'ledger', 'check', '--stdin'], {
+    input: JSON.stringify({ id: 'example-role-1' }), env, encoding: 'utf8',
+  }));
+  assert.equal(byId.duplicate, true);
+  assert.equal(byId.possibleDuplicate, false);
+  assert.equal(byId.reason, 'id');
+  assert.equal(byId.match.url, storedUrl);
+
+  const byEmployerJob = JSON.parse(execFileSync(process.execPath, [script, 'ledger', 'check', '--stdin'], {
+    input: JSON.stringify({ employerJobId: 'example:123', company: 'Example' }), env, encoding: 'utf8',
+  }));
+  assert.equal(byEmployerJob.duplicate, true);
+  assert.equal(byEmployerJob.possibleDuplicate, false);
+  assert.equal(byEmployerJob.reason, 'employer-job-id');
+
+  const newerUrl = 'https://jobs.example.com/123-new';
+  await writeFile(join(directory, 'applications.ndjson'), `${JSON.stringify({
+    id: 'example-role-1', company: 'Example', role: 'Senior Product Engineer', url: storedUrl, source: 'company', score: 88,
+    status: 'submitted', submittedAt: '2026-01-15T10:00:00Z', approval: 'STANDING AUTHORIZATION', answers: {}, employerJobId: 'example:123',
+  })}\n${JSON.stringify({
+    id: 'example-role-1b', company: 'Example', role: 'Senior Product Engineer', url: newerUrl, source: 'company', score: 88,
+    status: 'submitted', submittedAt: '2026-02-01T10:00:00Z', approval: 'STANDING AUTHORIZATION', answers: {},
+  })}\n`);
+
+  const byCompanyRole = JSON.parse(execFileSync(process.execPath, [script, 'ledger', 'check', '--stdin'], {
+    input: JSON.stringify({ company: 'Example', role: 'Senior Product Engineer' }), env, encoding: 'utf8',
+  }));
+  assert.equal(byCompanyRole.duplicate, false);
+  assert.equal(byCompanyRole.possibleDuplicate, true);
+  assert.equal(byCompanyRole.reason, 'company-role');
+  assert.equal(byCompanyRole.match.url, newerUrl);
+  assert.equal(byCompanyRole.match.id, 'example-role-1b');
+
+  const seniorUrl = 'https://jobs.example.com/senior';
+  const staffUrl = 'https://jobs.example.com/staff';
+  await writeFile(join(directory, 'applications.ndjson'), `${JSON.stringify({
+    id: 'example-senior', company: 'Example', role: 'Senior Software Engineer', url: seniorUrl, source: 'company', score: 88,
+    status: 'submitted', submittedAt: '2026-01-10T10:00:00Z', approval: 'STANDING AUTHORIZATION', answers: {},
+  })}\n${JSON.stringify({
+    id: 'example-staff', company: 'Example', role: 'Staff Software Engineer', url: staffUrl, source: 'company', score: 90,
+    status: 'submitted', submittedAt: '2026-02-10T10:00:00Z', approval: 'STANDING AUTHORIZATION', answers: {},
+  })}\n`);
+  const exactSenior = JSON.parse(execFileSync(process.execPath, [script, 'ledger', 'check', '--stdin'], {
+    input: JSON.stringify({ company: 'Example', role: 'Senior Software Engineer' }), env, encoding: 'utf8',
+  }));
+  assert.equal(exactSenior.possibleDuplicate, true);
+  assert.equal(exactSenior.match.id, 'example-senior');
+  assert.equal(exactSenior.match.url, seniorUrl);
+
+  await writeFile(join(directory, 'applications.ndjson'), `${JSON.stringify({
+    id: 'example-backend', company: 'Example', role: 'Backend Engineer', url: 'https://jobs.example.com/backend', source: 'company', score: 84,
+    status: 'submitted', submittedAt: '2026-01-05T10:00:00Z', approval: 'STANDING AUTHORIZATION', answers: {},
+  })}\n${JSON.stringify({
+    id: 'example-frontend', company: 'Example', role: 'Frontend Engineer', url: 'https://jobs.example.com/frontend', source: 'company', score: 85,
+    status: 'submitted', submittedAt: '2026-03-01T10:00:00Z', approval: 'STANDING AUTHORIZATION', answers: {},
+  })}\n`);
+  const ambiguousEngineer = JSON.parse(execFileSync(process.execPath, [script, 'ledger', 'check', '--stdin'], {
+    input: JSON.stringify({ company: 'Example', role: 'Engineer' }), env, encoding: 'utf8',
+  }));
+  assert.equal(ambiguousEngineer.duplicate, false);
+  assert.equal(ambiguousEngineer.possibleDuplicate, true);
+  assert.equal(ambiguousEngineer.reason, 'company-role');
+  assert.equal(ambiguousEngineer.match, null);
+
+  const identifierError = /ledger check requires at least one identifier set: url, id, employerJobId\+company, or company\+role/;
+  for (const input of [{}, { company: 'Example' }, { role: 'Senior Product Engineer' }]) {
+    const failed = await runCli(script, ['ledger', 'check', '--stdin'], input, env);
+    assert.equal(failed.code, 1);
+    assert.match(failed.stderr, identifierError);
+    assert.doesNotMatch(failed.stderr, /candidate\.url must/);
+  }
+
+  const malformedUrl = await runCli(script, ['ledger', 'check', '--stdin'], { id: 'example-role-1', url: 123 }, env);
+  assert.equal(malformedUrl.code, 1);
+  assert.match(malformedUrl.stderr, /candidate\.url must/);
+
+  assert.equal(byId.sameCompany, true);
+  assert.equal(byId.companyApplications.length, 1);
+  assert.equal(byId.companyApplications[0].id, 'example-role-1');
+
+  const invalidUrl = await runCli(script, ['ledger', 'check', '--stdin'], { url: 'not-a-url' }, env);
+  assert.equal(invalidUrl.code, 1);
+  assert.match(invalidUrl.stderr, /Invalid URL|invalid/i);
+
+  const missingAddUrl = await runCli(script, ['ledger', 'add', '--stdin'], {
+    id: 'example-role-2', company: 'Example', role: 'Staff Engineer', source: 'company', score: 80,
+    status: 'submitted', submittedAt: '2026-01-16T10:00:00Z', approval: 'STANDING AUTHORIZATION', answers: {},
+  }, env);
+  assert.equal(missingAddUrl.code, 1);
+  assert.match(missingAddUrl.stderr, /entry\.url must/);
+});
+
+test('records mail and looks up company+role in separate CLI processes', async (t) => {
+  const directory = await mkdtemp(join(tmpdir(), 'public-job-agent-outcome-then-check-'));
+  t.after(() => rm(directory, { recursive: true, force: true }));
+  const script = fileURLToPath(new URL('../scripts/job-application.mjs', import.meta.url));
+  await writeFile(join(directory, 'telemetry.json'), JSON.stringify({ version: 1, enabled: false, disclosed: true, graceConsumed: true, installationEventPending: false }));
+  const storedUrl = 'https://jobs.example.com/apollo-1';
+  await writeFile(join(directory, 'applications.ndjson'), `${JSON.stringify({
+    id: 'apollo-role-1', company: 'Apollo', role: 'Staff Engineer', url: storedUrl, source: 'company', score: 90,
+    status: 'submitted', submittedAt: '2026-01-15T10:00:00Z', approval: 'STANDING AUTHORIZATION', answers: {},
+  })}\n`);
+  const env = isolatedCliEnv(directory);
+  const outcome = JSON.parse(execFileSync(process.execPath, [script, 'ledger', 'outcome', '--stdin'], {
+    input: JSON.stringify({ id: 'apollo-role-1', status: 'rejected', occurredAt: '2026-01-20T09:00:00Z' }), env, encoding: 'utf8',
+  }));
+  assert.equal(outcome.recorded, true);
+  const check = JSON.parse(execFileSync(process.execPath, [script, 'ledger', 'check', '--stdin'], {
+    input: JSON.stringify({ company: 'Apollo', role: 'Staff Engineer' }), env, encoding: 'utf8',
+  }));
+  assert.equal(check.duplicate, false);
+  assert.equal(check.possibleDuplicate, true);
+  assert.equal(check.match.url, storedUrl);
+});
+
 test('records structured outcomes idempotently without duplicate rows', async (t) => {
   const directory = await mkdtemp(join(tmpdir(), 'public-job-agent-outcomes-'));
   t.after(() => rm(directory, { recursive: true, force: true }));

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.1",
   "description": "A privacy-first Agent Skill and CLI for evidence-based job discovery, application completion, and outcome tracking.",
   "license": "MIT",
   "type": "module",