terminalhire 0.5.0 → 0.7.0

package/dist/bin/jpi-bounties.js

@@ -680,6 +680,52 @@ function githubToFingerprint(p) {
   const seniorityBand = inferSeniority(p);
   return { skillTags, seniorityBand };
 }
+async function fetchOwnedRepoTraction(login, token) {
+  const computedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const empty = (status) => ({
+    status,
+    totalStars: 0,
+    totalForks: 0,
+    reposWithStars: 0,
+    top: [],
+    computedAt
+  });
+  let repos;
+  try {
+    repos = await ghFetch(
+      `/users/${login}/repos?sort=pushed&per_page=100`,
+      token
+    );
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const status = /HTTP 403|HTTP 429|rate limit/i.test(msg) ? "rate-limited" : "failed";
+    console.warn(`[github] ${login}: traction fetch failed (${status}) \u2014`, msg);
+    return empty(status);
+  }
+  if (!Array.isArray(repos)) return empty("failed");
+  const owned = repos.filter((r) => r && !r.fork && !r.archived);
+  let totalStars = 0;
+  let totalForks = 0;
+  let reposWithStars = 0;
+  const ranked = [];
+  for (const r of owned) {
+    const stars = typeof r.stargazers_count === "number" ? r.stargazers_count : 0;
+    const forks = typeof r.forks_count === "number" ? r.forks_count : 0;
+    totalStars += stars;
+    totalForks += forks;
+    if (stars >= 1) reposWithStars++;
+    ranked.push({ name: r.name, stars, forks });
+  }
+  ranked.sort((a, b) => b.stars - a.stars || b.forks - a.forks);
+  return {
+    status: "ok",
+    totalStars,
+    totalForks,
+    reposWithStars,
+    top: ranked.slice(0, TRACTION_TOP_N),
+    computedAt
+  };
+}
 async function ghFetchRaw(path, token) {
   return fetch(`https://api.github.com${path}`, { headers: ghHeaders(token) });
 }
@@ -888,11 +934,12 @@ function deriveResumeTrend(cred, repoRecency, now = Date.now()) {
   }
   return scored.sort((a, b) => b.weight - a.weight).slice(0, 12).map((s) => s.t);
 }
-var MIN_STARS, MIN_CONTRIBUTORS, CANDIDATE_PR_PAGE, TRIVIAL_PR_TITLE, RESUME_DECAY_HALF_LIFE_MS, RESUME_MIN_SCORE;
+var TRACTION_TOP_N, MIN_STARS, MIN_CONTRIBUTORS, CANDIDATE_PR_PAGE, TRIVIAL_PR_TITLE, RESUME_DECAY_HALF_LIFE_MS, RESUME_MIN_SCORE;
 var init_github = __esm({
   "../../packages/core/src/github.ts"() {
     "use strict";
     init_vocabulary();
+    TRACTION_TOP_N = 6;
     MIN_STARS = 50;
     MIN_CONTRIBUTORS = 10;
     CANDIDATE_PR_PAGE = 50;
@@ -2221,6 +2268,51 @@ var init_workable = __esm({
   }
 });
 
+// ../../packages/core/src/feeds/directory.ts
+function personCardToJob(row) {
+  const tags = [...row.skill_tags];
+  return {
+    id: `dev:${row.login}`,
+    source: "person",
+    title: row.name ?? row.login,
+    company: row.login,
+    url: `/r/${row.login}`,
+    remote: true,
+    tags,
+    coreTags: tags.slice(0, TOP_CORE_TAGS),
+    roleType: "full_time",
+    applyMode: "direct"
+  };
+}
+function buildDirectoryIndex(people, opts) {
+  return {
+    builtAt: opts?.builtAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    cards: people.map(personCardToJob)
+  };
+}
+function projectCardToJob(row) {
+  const tags = [...row.needed_skills];
+  return {
+    id: `proj:${row.id}`,
+    source: "project",
+    title: row.title,
+    company: row.owner_login,
+    url: `/r/${row.owner_login}`,
+    remote: true,
+    tags,
+    coreTags: tags.slice(0, TOP_CORE_TAGS),
+    roleType: "full_time",
+    applyMode: "direct"
+  };
+}
+var TOP_CORE_TAGS;
+var init_directory = __esm({
+  "../../packages/core/src/feeds/directory.ts"() {
+    "use strict";
+    TOP_CORE_TAGS = 4;
+  }
+});
+
 // ../../packages/core/src/feeds/index.ts
 async function aggregateBounties(opts) {
   const [gh, op] = await Promise.all([
@@ -2337,6 +2429,7 @@ var init_feeds = __esm({
     init_github_bounties();
     init_opire();
     init_workable();
+    init_directory();
     init_bounty_gate();
     init_bounty_gate();
     FEEDS = [greenhouse, ashby, lever, workable, himalayas, wwr, hn];
@@ -2537,6 +2630,176 @@ var init_indexer = __esm({
   }
 });
 
+// ../../packages/core/src/intro.ts
+function buildIntroPayload(input) {
+  const payload = {
+    requesterLogin: input.requesterLogin,
+    requesterDisplayName: input.requesterDisplayName,
+    requesterContact: input.requesterContact,
+    targetLogin: input.targetLogin
+  };
+  const note = input.note?.trim();
+  if (note) payload.note = note;
+  return payload;
+}
+function rejectExtraIntroFields(body) {
+  for (const key of Object.keys(body)) {
+    if (!INTRO_ALLOWED_SET.has(key)) {
+      return `intro payload contains disallowed field: "${key}"`;
+    }
+  }
+  return null;
+}
+function validateIntroPayload(body) {
+  if (typeof body !== "object" || body === null || Array.isArray(body)) {
+    return { ok: false, reason: "intro payload must be a JSON object" };
+  }
+  const b = body;
+  const extra = rejectExtraIntroFields(b);
+  if (extra) return { ok: false, reason: extra };
+  const ok = (v, max) => typeof v === "string" && v.trim().length > 0 && v.length <= max;
+  if (!ok(b.requesterLogin, MAX_SHORT)) return { ok: false, reason: "requesterLogin is required" };
+  if (!ok(b.requesterDisplayName, MAX_SHORT)) return { ok: false, reason: "requesterDisplayName is required" };
+  if (!ok(b.requesterContact, MAX_SHORT)) return { ok: false, reason: "requesterContact is required" };
+  if (!ok(b.targetLogin, MAX_SHORT)) return { ok: false, reason: "targetLogin is required" };
+  if (b.note !== void 0 && (typeof b.note !== "string" || b.note.length > MAX_NOTE)) {
+    return { ok: false, reason: "note must be a string of at most 500 chars" };
+  }
+  const value = {
+    requesterLogin: b.requesterLogin.trim(),
+    requesterDisplayName: b.requesterDisplayName.trim(),
+    requesterContact: b.requesterContact.trim(),
+    targetLogin: b.targetLogin.trim()
+  };
+  const note = typeof b.note === "string" ? b.note.trim() : "";
+  if (note) value.note = note;
+  return { ok: true, value };
+}
+function introRateLimitCheck(history, now, opts) {
+  const cutoff = now - opts.windowMs;
+  const recent = history.filter((t) => t > cutoff);
+  if (recent.length >= opts.max) {
+    const oldest = recent[0] ?? now;
+    return { allowed: false, retained: recent, retryAfterMs: Math.max(0, oldest + opts.windowMs - now) };
+  }
+  return { allowed: true, retained: [...recent, now], retryAfterMs: 0 };
+}
+function isOverIntroLimit(recentCount, max) {
+  return recentCount >= max;
+}
+function composeIntroEmail(args2) {
+  const subject = `New intro request from @${args2.requesterLogin} \xB7 terminalhire`;
+  const text = `@${args2.requesterLogin} wants an intro to you on terminalhire.
+
+Sign in to view the request and choose whether to share your contact back:
+${args2.dashboardUrl}
+
+You control whether this connects \u2014 no contact details are shared unless you accept.
+
+\u2014 Terminalhire`;
+  return { subject, text };
+}
+function introActorRole(intro, actorLogin) {
+  const a = actorLogin.trim().toLowerCase();
+  if (a && a === intro.targetLogin.trim().toLowerCase()) return "target";
+  if (a && a === intro.requesterLogin.trim().toLowerCase()) return "requester";
+  return "other";
+}
+function authorizeIntroDecision(intro, actorLogin) {
+  const role = introActorRole(intro, actorLogin);
+  if (role === "target") return { ok: true };
+  if (role === "requester") {
+    return { ok: false, status: 403, reason: "the requester cannot accept or decline their own intro request" };
+  }
+  return { ok: false, status: 404, reason: "intro not found" };
+}
+function authorizeIntroDeletion(intro, actorLogin) {
+  const role = introActorRole(intro, actorLogin);
+  if (role === "other") return { ok: false, status: 404, reason: "intro not found" };
+  return { ok: true };
+}
+function revealIntroContacts(intro) {
+  if (intro.status !== "accepted") return { toRequester: null, toTarget: null };
+  return { toRequester: intro.targetContact ?? null, toTarget: intro.requesterContact };
+}
+function validateTargetContact(v) {
+  if (typeof v !== "string" || v.trim().length === 0) return { ok: false, reason: "targetContact is required" };
+  if (v.length > MAX_SHORT) return { ok: false, reason: `targetContact must be at most ${MAX_SHORT} chars` };
+  return { ok: true, value: v.trim() };
+}
+function buildIntroListItem(intro, viewerLogin) {
+  const role = introActorRole(intro, viewerLogin);
+  if (role === "other") return null;
+  const reveal = revealIntroContacts(intro);
+  if (role === "target") {
+    return {
+      id: intro.id,
+      role: "incoming",
+      counterpartyLogin: intro.requesterLogin,
+      status: intro.status,
+      note: intro.note ?? null,
+      contact: reveal.toTarget
+    };
+  }
+  return {
+    id: intro.id,
+    role: "outgoing",
+    counterpartyLogin: intro.targetLogin,
+    status: intro.status,
+    note: intro.note ?? null,
+    contact: reveal.toRequester
+  };
+}
+function composeIntroAcceptedEmail(args2) {
+  const subject = `Intro connected with @${args2.counterpartyLogin} \xB7 terminalhire`;
+  const lead = args2.recipientRole === "requester" ? `@${args2.counterpartyLogin} accepted your intro request on terminalhire.` : `You accepted @${args2.counterpartyLogin}'s intro request on terminalhire.`;
+  const text = `${lead}
+
+You can now reach them directly:
+    @${args2.counterpartyLogin} \u2014 ${args2.counterpartyContact}
+
+Take it from here.
+
+\u2014 Terminalhire`;
+  return { subject, text };
+}
+function introRetentionAction(row, now) {
+  if (row.status === "pending") {
+    const created = Date.parse(row.createdAt);
+    if (Number.isFinite(created) && now - created > INTRO_PENDING_TTL_MS) return "purge";
+    return "keep";
+  }
+  if (row.status === "declined") {
+    return row.hasContact ? "scrub-declined" : "keep";
+  }
+  if (row.status === "accepted") {
+    const updated = Date.parse(row.updatedAt);
+    if (row.hasContact && Number.isFinite(updated) && now - updated > INTRO_ACCEPTED_TTL_MS) {
+      return "expire-accepted";
+    }
+    return "keep";
+  }
+  return "keep";
+}
+var INTRO_ALLOWED_FIELDS, INTRO_ALLOWED_SET, MAX_SHORT, MAX_NOTE, INTRO_PENDING_TTL_MS, INTRO_ACCEPTED_TTL_MS;
+var init_intro = __esm({
+  "../../packages/core/src/intro.ts"() {
+    "use strict";
+    INTRO_ALLOWED_FIELDS = [
+      "requesterLogin",
+      "requesterDisplayName",
+      "requesterContact",
+      "note",
+      "targetLogin"
+    ];
+    INTRO_ALLOWED_SET = new Set(INTRO_ALLOWED_FIELDS);
+    MAX_SHORT = 200;
+    MAX_NOTE = 500;
+    INTRO_PENDING_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
+    INTRO_ACCEPTED_TTL_MS = 365 * 24 * 60 * 60 * 1e3;
+  }
+});
+
 // ../../packages/core/src/index.ts
 var src_exports = {};
 __export(src_exports, {
@@ -2552,6 +2815,9 @@ __export(src_exports, {
   GRAPH: () => GRAPH,
   GREENHOUSE_SLUGS_BY_TIER: () => GREENHOUSE_SLUGS_BY_TIER,
   IDF_BACKGROUND: () => IDF_BACKGROUND,
+  INTRO_ACCEPTED_TTL_MS: () => INTRO_ACCEPTED_TTL_MS,
+  INTRO_ALLOWED_FIELDS: () => INTRO_ALLOWED_FIELDS,
+  INTRO_PENDING_TTL_MS: () => INTRO_PENDING_TTL_MS,
   LEVER_SLUGS_BY_TIER: () => LEVER_SLUGS_BY_TIER,
   SYNONYMS: () => SYNONYMS,
   VOCABULARY: () => VOCABULARY,
@@ -2560,10 +2826,17 @@ __export(src_exports, {
   aggregate: () => aggregate,
   aggregateBounties: () => aggregateBounties,
   ashby: () => ashby,
+  authorizeIntroDecision: () => authorizeIntroDecision,
+  authorizeIntroDeletion: () => authorizeIntroDeletion,
   bestAcceptanceDomain: () => bestAcceptanceDomain,
+  buildDirectoryIndex: () => buildDirectoryIndex,
   buildGraph: () => buildGraph,
   buildIndex: () => buildIndex,
+  buildIntroListItem: () => buildIntroListItem,
+  buildIntroPayload: () => buildIntroPayload,
   buildReason: () => buildReason,
+  composeIntroAcceptedEmail: () => composeIntroAcceptedEmail,
+  composeIntroEmail: () => composeIntroEmail,
   computeAcceptanceCredential: () => computeAcceptanceCredential,
   computeAcceptanceCredentialPublic: () => computeAcceptanceCredentialPublic,
   coreTagsFromTitle: () => coreTagsFromTitle,
@@ -2571,6 +2844,7 @@ __export(src_exports, {
   expandWeighted: () => expandWeighted,
   extractSkillTags: () => extractSkillTags,
   fetchGitHubProfile: () => fetchGitHubProfile,
+  fetchOwnedRepoTraction: () => fetchOwnedRepoTraction,
   fetchRepoRecency: () => fetchRepoRecency,
   flattenTiers: () => flattenTiers,
   getBuyer: () => getBuyer,
@@ -2579,7 +2853,11 @@ __export(src_exports, {
   greenhouse: () => greenhouse,
   himalayas: () => himalayas,
   hn: () => hn,
+  introActorRole: () => introActorRole,
+  introRateLimitCheck: () => introRateLimitCheck,
+  introRetentionAction: () => introRetentionAction,
   isBounty: () => isBounty,
+  isOverIntroLimit: () => isOverIntroLimit,
   lever: () => lever,
   loadPartnerRoles: () => loadPartnerRoles,
   looksLikeEngRole: () => looksLikeEngRole,
@@ -2587,8 +2865,14 @@ __export(src_exports, {
   normalize: () => normalize,
   opire: () => opire,
   passesMaturityGate: () => passesMaturityGate,
+  personCardToJob: () => personCardToJob,
+  projectCardToJob: () => projectCardToJob,
+  rejectExtraIntroFields: () => rejectExtraIntroFields,
+  revealIntroContacts: () => revealIntroContacts,
   tokenize: () => tokenize,
   validateGraph: () => validateGraph,
+  validateIntroPayload: () => validateIntroPayload,
+  validateTargetContact: () => validateTargetContact,
   workable: () => workable,
   wwr: () => wwr
 });
@@ -2602,6 +2886,7 @@ var init_src = __esm({
     init_indexer();
     init_partners();
     init_github();
+    init_intro();
   }
 });
 

package/dist/bin/jpi-claim.js

@@ -106,10 +106,56 @@ var init_claims = __esm({
 import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
 import { join as join2 } from "path";
 import { homedir as homedir2 } from "os";
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { createInterface } from "readline";
 var TERMINALHIRE_DIR2 = join2(homedir2(), ".terminalhire");
 var INDEX_CACHE_FILE = join2(TERMINALHIRE_DIR2, "index-cache.json");
 var GH_API = "https://api.github.com";
 var GH_HEADERS = { "User-Agent": "terminalhire-claim", Accept: "application/vnd.github+json" };
+var pExecFile = promisify(execFile);
+async function sh(cmd, args, opts = {}) {
+  const { stdout } = await pExecFile(cmd, args, { ...opts, shell: false, maxBuffer: 16 * 1024 * 1024 });
+  return String(stdout).trim();
+}
+async function confirm(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const ans = await new Promise((resolve) => rl.question(question, resolve));
+    return /^y(es)?$/i.test(String(ans).trim());
+  } finally {
+    rl.close();
+  }
+}
+var VALUE_FLAGS = /* @__PURE__ */ new Set(["worktree", "branch"]);
+function parseArgs(argv) {
+  const flags = {};
+  const positional = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a.startsWith("--")) {
+      const key = a.slice(2);
+      if (VALUE_FLAGS.has(key)) {
+        const val = argv[i + 1];
+        if (val === void 0 || val.startsWith("--")) {
+          console.error(`terminalhire claim: --${key} requires a value.`);
+          process.exit(1);
+        }
+        flags[key] = val;
+        i++;
+      } else {
+        flags[key] = true;
+      }
+    } else {
+      positional.push(a);
+    }
+  }
+  return { flags, positional };
+}
+function parseRepoFromRemote(url) {
+  const m = String(url ?? "").trim().match(/github\.com[:/]+([^/]+)\/([^/]+?)(?:\.git)?\/?$/);
+  return m ? `${m[1]}/${m[2]}` : null;
+}
 function findBountyInCache(bountyId) {
   try {
     if (!existsSync2(INDEX_CACHE_FILE)) return null;
@@ -264,7 +310,10 @@ async function cmdRecord(arg) {
   console.log("   \u2022 MUST NOT `git push` or `gh pr` \u2014 pushing happens only via `terminalhire submit`");
   console.log("   \u2022 clone + static analysis + patch only; NO test/build execution without explicit approval");
   console.log("   \u2022 no access to ~/.terminalhire (the executor never needs your profile)");
-  console.log("\n  Next: do the work, then `terminalhire claim update " + claim.id + " <state>` as you progress.");
+  console.log("\n  Next:");
+  console.log("   1. record the worktree:  terminalhire claim attach " + claim.id + " --worktree <path> --branch <branch>");
+  console.log("   2. do the work + review, then mark it cleared:  terminalhire claim update " + claim.id + " ready");
+  console.log("   3. publish (pushes to your fork + opens the PR):  terminalhire claim submit " + claim.id);
 }
 async function cmdPreview(arg, { json } = {}) {
   if (!arg) {
@@ -390,33 +439,223 @@ async function cmdRelease(id) {
   console.log(removed ? `Released claim: ${id}` : `terminalhire claim: no claim with id '${id}'.`);
   if (!removed) process.exit(1);
 }
+async function cmdAttach(id, worktree, branch) {
+  const claims = await Promise.resolve().then(() => (init_claims(), claims_exports));
+  if (!id || !worktree || !branch) {
+    console.error("Usage: terminalhire claim attach <id> --worktree <path> --branch <branchName>");
+    console.error("  Records the worktree + branch so `terminalhire claim submit` can verify identity before pushing.");
+    process.exit(1);
+  }
+  if (!claims.findClaim(id)) {
+    console.error(`terminalhire claim: no claim with id '${id}'.`);
+    process.exit(1);
+  }
+  let toplevel;
+  try {
+    toplevel = await sh("git", ["-C", worktree, "rev-parse", "--show-toplevel"]);
+  } catch {
+    console.error(`terminalhire claim: '${worktree}' is not a git work tree.`);
+    process.exit(1);
+  }
+  claims.updateClaim(id, { worktreePath: toplevel, branch });
+  console.log(`Attached ${id}: worktree=${toplevel} branch=${branch}`);
+}
+async function cmdSubmit(id, worktreeOverride) {
+  const claims = await Promise.resolve().then(() => (init_claims(), claims_exports));
+  if (!id) {
+    console.error("Usage: terminalhire claim submit <id> [--worktree <path>]");
+    process.exit(1);
+  }
+  const claim = claims.findClaim(id);
+  if (!claim) {
+    console.error(`terminalhire claim: no claim with id '${id}'.`);
+    process.exit(1);
+  }
+  if (claim.state !== "ready") {
+    console.error(
+      `terminalhire claim: ${id} is '${claim.state}', not 'ready'. Submit only runs after the review gate clears it:
+  terminalhire claim update ${id} ready`
+    );
+    process.exit(1);
+  }
+  if (claim.review && claim.review.verdict === "revise") {
+    console.error(`terminalhire claim: ${id} review verdict is 'revise' \u2014 the gate said do not submit. Resolve blockers and re-review first.`);
+    process.exit(1);
+  }
+  if (!claim.worktreePath || !claim.branch) {
+    console.error(
+      `terminalhire claim: ${id} has no recorded worktree/branch \u2014 cannot verify what to push. Run:
+  terminalhire claim attach ${id} --worktree <path> --branch <branch>`
+    );
+    process.exit(1);
+  }
+  const inspectDir = worktreeOverride || process.cwd();
+  let toplevel;
+  try {
+    toplevel = await sh("git", ["-C", inspectDir, "rev-parse", "--show-toplevel"]);
+  } catch {
+    console.error(
+      `terminalhire claim: '${inspectDir}' is not a git work tree.
+  Run submit from inside the claim's worktree (or pass --worktree <path>).`
+    );
+    process.exit(1);
+  }
+  if (toplevel !== claim.worktreePath) {
+    console.error(
+      `terminalhire claim: worktree mismatch \u2014 refusing to push.
+  expected: ${claim.worktreePath}
+  found:    ${toplevel}
+  Run submit from inside the claim's worktree (or pass --worktree <path>).`
+    );
+    process.exit(1);
+  }
+  const wt = toplevel;
+  const curBranch = await sh("git", ["-C", wt, "rev-parse", "--abbrev-ref", "HEAD"]);
+  if (curBranch !== claim.branch) {
+    console.error(
+      `terminalhire claim: branch mismatch \u2014 refusing to push.
+  expected: ${claim.branch}
+  found:    ${curBranch}
+  Check out the claim's branch first.`
+    );
+    process.exit(1);
+  }
+  let defaultBranch = null;
+  try {
+    defaultBranch = (await sh("git", ["-C", wt, "symbolic-ref", "--short", "refs/remotes/origin/HEAD"])).replace(/^origin\//, "");
+  } catch {
+  }
+  if (defaultBranch && claim.branch === defaultBranch) {
+    console.error(`terminalhire claim: '${claim.branch}' is the default branch \u2014 open the PR from a feature branch.`);
+    process.exit(1);
+  }
+  if (defaultBranch) {
+    let ahead = "0";
+    try {
+      ahead = await sh("git", ["-C", wt, "rev-list", "--count", `origin/${defaultBranch}..HEAD`]);
+    } catch {
+      ahead = "1";
+    }
+    if (ahead === "0") {
+      console.error(`terminalhire claim: branch has no commits ahead of origin/${defaultBranch} \u2014 nothing to submit.`);
+      process.exit(1);
+    }
+  }
+  const dirty = await sh("git", ["-C", wt, "status", "--porcelain"]);
+  if (dirty) {
+    console.error("terminalhire claim: working tree is not clean \u2014 commit or stash before submitting (submit pushes what was reviewed).");
+    process.exit(1);
+  }
+  let originUrl;
+  try {
+    originUrl = await sh("git", ["-C", wt, "remote", "get-url", "origin"]);
+  } catch {
+    console.error("terminalhire claim: no 'origin' remote in the worktree.");
+    process.exit(1);
+  }
+  const originRepo = parseRepoFromRemote(originUrl);
+  if (!originRepo) {
+    console.error(`terminalhire claim: could not parse owner/repo from origin (${originUrl}).`);
+    process.exit(1);
+  }
+  if (originRepo.toLowerCase() === claim.repoFullName.toLowerCase()) {
+    console.error(
+      `terminalhire claim: origin points at the UPSTREAM bounty repo (${claim.repoFullName}), not a fork.
+  Pushing would create a branch directly on the target repo. Fork first:
+    gh repo fork ${claim.repoFullName} --clone=false
+  set your fork as 'origin' (or push it there), then retry.`
+    );
+    process.exit(1);
+  }
+  let ghUser;
+  try {
+    ghUser = await sh("gh", ["api", "user", "-q", ".login"]);
+  } catch {
+    console.error("terminalhire claim: 'gh' CLI not available or not authenticated. Run 'gh auth login'.");
+    process.exit(1);
+  }
+  const upstream = claim.repoFullName;
+  const head = `${ghUser}:${claim.branch}`;
+  console.log(`
+  SUBMIT \xB7 ${claim.title}`);
+  console.log(`  upstream: ${upstream}`);
+  console.log(`  fork:     ${originRepo}`);
+  console.log(`  branch:   ${claim.branch}`);
+  console.log(`  head:     ${head}`);
+  console.log(`  issue:    ${claim.issueUrl}`);
+  const ok = await confirm(`
+  Push '${claim.branch}' to ${originRepo} and open a PR against ${upstream}? (y/N) `);
+  if (!ok) {
+    console.log("Aborted \u2014 nothing pushed.");
+    return;
+  }
+  try {
+    await sh("git", ["-C", wt, "push", "origin", claim.branch]);
+  } catch (err) {
+    console.error(`terminalhire claim: git push failed (NOT force-pushed). ${err.stderr || err.message || err}`);
+    console.error(`  Resolve and retry, or open the PR manually then: terminalhire claim update ${id} submitted <prUrl>`);
+    process.exit(1);
+  }
+  let prUrl = null;
+  try {
+    const existing = await sh("gh", ["pr", "list", "--repo", upstream, "--head", head, "--state", "open", "--json", "url", "-q", ".[0].url // empty"]);
+    if (existing) prUrl = existing;
+  } catch {
+  }
+  if (!prUrl) {
+    const issueNum = (parseGitHubUrl(claim.issueUrl) || {}).number;
+    const body = issueNum ? `Closes #${issueNum}` : "";
+    try {
+      const out = await sh("gh", ["pr", "create", "--repo", upstream, "--head", head, "--title", claim.title, "--body", body]);
+      prUrl = out.split("\n").map((l) => l.trim()).filter((l) => l.startsWith("https://github.com/")).pop() || null;
+    } catch (err) {
+      console.error(`terminalhire claim: branch pushed, but 'gh pr create' failed. ${err.stderr || err.message || err}`);
+      console.error(`  Open the PR manually (gh pr create / web UI), then: terminalhire claim update ${id} submitted <prUrl>`);
+      process.exit(1);
+    }
+  }
+  if (!prUrl || !parseGitHubUrl(prUrl)) {
+    console.error(`terminalhire claim: could not determine the PR URL. Set it manually: terminalhire claim update ${id} submitted <prUrl>`);
+    process.exit(1);
+  }
+  claims.updateClaim(id, { state: "submitted", prUrl });
+  console.log(`
+\u2713 Submitted ${id} \u2192 ${prUrl}`);
+  console.log(`  Run 'terminalhire claim status ${id}' after the maintainer acts to fold the merge into your accepted-PR rate.`);
+}
 async function run() {
   const verb = process.argv[2];
-  const rest = process.argv.slice(3).filter((a) => !a.startsWith("--"));
-  const active = process.argv.includes("--active");
-  const json = process.argv.includes("--json");
+  const { flags, positional } = parseArgs(process.argv.slice(3));
+  const active = Boolean(flags.active);
+  const json = Boolean(flags.json);
   try {
     switch (verb) {
       case "preview":
-        await cmdPreview(rest[0], { json });
+        await cmdPreview(positional[0], { json });
         break;
       case "record":
-        await cmdRecord(rest[0]);
+        await cmdRecord(positional[0]);
         break;
       case "list":
         await cmdList(active);
         break;
       case "status":
-        await cmdStatus(rest[0]);
+        await cmdStatus(positional[0]);
         break;
       case "update":
-        await cmdUpdate(rest[0], rest[1], rest[2]);
+        await cmdUpdate(positional[0], positional[1], positional[2]);
+        break;
+      case "attach":
+        await cmdAttach(positional[0], flags.worktree, flags.branch);
+        break;
+      case "submit":
+        await cmdSubmit(positional[0], flags.worktree);
         break;
       case "release":
-        await cmdRelease(rest[0]);
+        await cmdRelease(positional[0]);
         break;
       default:
-        console.error(`terminalhire claim: unknown verb '${verb ?? ""}'. Expected: preview | record | list | status | update | release`);
+        console.error(`terminalhire claim: unknown verb '${verb ?? ""}'. Expected: preview | record | attach | list | status | update | submit | release`);
         process.exit(1);
     }
   } catch (err) {