@vegastack/skills 0.17.0 → 0.18.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vegastack/skills",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "Installer and verifier for VegaStack Agent Skills (Claude Code, Codex, and Hermes)",
   "license": "MIT",
   "type": "module",

package/skill/dev-implement/SKILL.md

@@ -17,18 +17,18 @@ When the operator directly asks in chat for a change, their words are the approv
 
 - Run the deterministic guard first: `node <path-to-this-skill>/scripts/preflight.mjs --issue <n> --me $(gh api user -q .login) --json` (add `--repo <o/r> --dev-md <path>` when running outside the project root) — exit 2 stops you with its reasons (open + `ready` state, approval marker, scope label, plan approval on full-plan, Assumptions section, blockers, assignee, repo match); exit 1 passes with warnings — read them into the ledger. Resume and corrections runs pass `--expect working` / `--expect for-operator`.
 - Then the judgment checks: read the complete brief plus parent issue and milestone for context; re-verify the brief's touch points against the current code (things drift between approval and execution) — including the version-impact line; volatile dependency claims per `dev-architect`'s verify protocol; a full-plan issue's plan still matches reality. A material decision left open — even outside a formal Assumptions section — or reality contradicting brief or plan is a stop: one `handback` comment with the smallest question, `needs-operator`.
-- Resuming a dead session's issue: the operator's explicit handover is required; then follow the resume protocol in [ledger-and-resume](references/ledger-and-resume.md) — brief → plan → ledger → `git log`, nothing else.
+- Resuming a dead session's issue: the operator's explicit handover is required; then follow the resume protocol in [ledger-and-resume](references/ledger-and-resume.md) — brief → plan → ledger → `git log`, nothing else. When the claim is instead being abandoned (nothing worth resuming), the operator releases it with `node <path-to-this-skill>/scripts/reclaim.mjs --issue <n>` (`working` → `ready`, unassign; refuses a still-fresh ledger unless `--force`) — never an automatic reclaim.
 
 ## Claim
 
-Assign yourself, swap `ready` → `working`, branch from the default branch per dev.md's `branch:` knob, and **create the ledger comment as your first write**. Record each task's base sha before starting it.
+One session owns one issue, end to end — never hold two `working` claims at once. Assign yourself, swap `ready` → `working`, branch from the default branch per dev.md's `branch:` knob, and **create the ledger comment as your first write** — that comment's edit time is this claim's only liveness signal (dev-status reads a long-silent ledger as a possibly-orphaned claim), so a claim whose session dies before writing it is invisible. Record each task's base sha before starting it.
 
 ## Build — dark, test-first, checkpointed
 
 No progress updates, no questions. A `fix:` issue's diagnosis runs under the `dev-debug` skill — its phases govern the investigation inside this dark mode, and its winning suspect feeds the evidence comment. A spike the brief flagged runs first — its result opens the evidence comment and shapes the rest of the build. Then work the plan task by task:
 
 - **Red before green.** Write the failing test first — at the seams the brief names, never elsewhere — watch it fail for the stated reason, implement the minimal code, watch it pass. One slice at a time. The tests-are-real rubric (implementation-coupled, tautological, horizontal-sliced — defined in `dev-review`'s dispatch prompts) applies to your own tests before a reviewer ever sees them.
-- **Checkpoint the ledger** after every task (tick the plan checkbox in the same pass) and at every ruling, per the reference.
+- **Checkpoint the ledger** after every task — and in the same pass tick the matching `[x]` in the *plan* comment (a second write, to a different comment than the ledger, and the one the operator's progress view reads — so the easiest to skip and the one that silently rots). Checkpoint at every ruling too; each checkpoint is also the claim's heartbeat, so never batch them "for later," per the reference.
 - **Transitory artifacts** — subagent reports, scratch diffs, drafts — live in `.vegastack/.tmp/<issue>-<slug>/`; subagents write full output to files there and return short status.
 - Decide routine things yourself and ledger the rulings. A structural choice mid-build — a new dependency, table, or service — checks `dev-architect`'s trigger discipline first; a moving part with no named trigger is a stop condition.
 - **The scope ratchet is a stop condition:** work revealed bigger than the issue's scope class (or plainly exceeding one session) → one `handback` comment proposing the upgrade or split (dev-plan's ratchet rules), `needs-operator`, stop.
@@ -71,7 +71,7 @@ Run the `dev-review` skill per dev.md's `review:` knob — fresh subagent axes b
 Branch: <name> @ <sha7>
 ```
 
-The tail's sha stays bare: GitHub auto-links a 7-character sha mid-comment as soon as the commit is on the remote, so the tail becomes a live commit link the moment the branch is pushed — while an explicit `/commit/<sha>` link written at hand-back points at a commit that has not been pushed yet, and 404s. The `**Review:**` line is the one home of surfaced rulings: every ledger `Ruling:` appears there, in the order made. Run `node <path-to-this-skill>/scripts/evidence-check.mjs --file <draft> --json` before posting — exit 2 means the shape is incomplete; fix, don't post. Post it, swap `working` → `for-operator`, stop, and close with the plain-language summary (which repeats, never replaces, the evidence content): what was built, which paths were taken, the rulings, what's worth the operator double-checking.
+The tail's sha stays bare: GitHub auto-links a 7-character sha mid-comment as soon as the commit is on the remote, so the tail becomes a live commit link the moment the branch is pushed — while an explicit `/commit/<sha>` link written at hand-back points at a commit that has not been pushed yet, and 404s. The `**Review:**` line is the one home of surfaced rulings: every ledger `Ruling:` appears there, in the order made. Run `node <path-to-this-skill>/scripts/evidence-check.mjs --file <draft> --issue <n> --json` before posting — it checks the draft's shape and, with `--issue`, that the plan comment's `[x]` boxes reflect the ledger's completed tasks; exit 2 means the shape is incomplete or the checkboxes lag the ledger — fix, don't post. Post it, swap `working` → `for-operator`, stop, and close with the plain-language summary (which repeats, never replaces, the evidence content): what was built, which paths were taken, the rulings, what's worth the operator double-checking.
 
 ## Corrections loop — code and docs move together
 

package/skill/dev-implement/references/ledger-and-resume.md

@@ -6,16 +6,18 @@ The ledger comment's format, line vocabulary, and the resume read-order (brief
 
 Create the ledger comment as the session's **first write after claiming** — before any code — with just the marker and heading. Then checkpoint, editing in place:
 
-- **After each plan task completes** — and tick the matching checkbox in the plan comment in the same pass. Record the task's base sha *before* starting it, so the `complete` line's commit range is exact.
+- **After each plan task completes** — and tick the matching `[x]` in the plan comment in the same pass. That box is a second write, to a different comment, that your own resume path never reads — so it is the one that silently lags reality, while the operator's progress view depends on it. The hand-back guard (`evidence-check --issue`) blocks when the ledger's completed tasks outnumber the plan's checked boxes. Record the task's base sha *before* starting it, so the `complete` line's commit range is exact.
 - **After each review fix round**, with the addressed/open counts.
 - **At every dark-mode judgment call.** A ruling is any decision the brief/plan didn't make for you that a reviewer or the operator could reasonably question. Rulings are cheap; unrecorded decisions are debt.
 - **On findings deferred or parked at review**, per dev-review's adjudication lines.
 
 Never batch checkpoints "for later" — the ledger's value is exactly that a crash between checkpoints loses one task, not the map. Under concurrent edits, last-writer-wins on one comment is accepted (single-operator workflow); note a clobber if you ever see one.
 
+The ledger's edit time is also this claim's **heartbeat** — the only liveness signal an agent session exposes. dev-status reads a ledger silent past the orphan threshold (6h) as a *possibly-orphaned* claim: the session likely died before hand-back. A session that runs for days but keeps checkpointing never trips it; a dead one's ledger freezes. A single long task can legitimately go quiet — so checkpoint at rulings within it too, keeping the pulse alive — and the flag is always the operator's to act on (check, resume, or reclaim), never an automatic reset.
+
 ## Resuming — dev-implement's additions to the protocol
 
-- The takeover of a `working` issue requires the operator's explicit handover word; the protocol never makes claiming automatic.
+- The takeover of a `working` issue requires the operator's explicit handover word; the protocol never makes claiming automatic. When nothing is worth resuming, the operator releases the claim instead with `scripts/reclaim.mjs --issue <n>` — `working` → `ready`, unassigned — which refuses a ledger still fresh under the orphan threshold unless `--force`.
 - Corroborate, don't re-verify: the commits the ledger names should exist in `git log` — reconcile the ranges; a mismatch is a `handback`, not a guess.
 - A task whose last line is a fix round is mid-loop — resume at the next round with the open findings; a later `complete` line supersedes earlier rounds.
 - Recorded rulings bind the resumed session: build on them, and surface disagreement in the evidence comment instead of re-litigating.

package/skill/dev-implement/scripts/evidence-check.mjs

@@ -7,7 +7,7 @@
 import { readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { parseFlags, parseMarker, renderResult } from './lib/gh.mjs';
+import { GhUnavailable, findMarkerComment, ghJson, parseFlags, parseMarker, renderResult } from './lib/gh.mjs';
 
 const REQUIRED_SECTIONS = [
   [/\*\*Done:\*\*/, '**Done:** section'],
@@ -38,18 +38,66 @@ export function checkEvidence(text) {
   return { blocks, warns: [] };
 }
 
+// The plan comment's checkboxes and the ledger's completed tasks are two records
+// of the same fact, and the checkbox — a second write, to a different comment
+// than the ledger the session already maintains — is the one that silently rots.
+// At hand-back the ledger's completed tasks must be reflected in the plan's
+// checkboxes, or the operator reads a false x/y. Distinct task numbers with a
+// `complete` line in the ledger, versus `[x]` boxes in the plan.
+export function checkTaskConsistency(comments) {
+  const blocks = [];
+  const warns = [];
+  const plan = findMarkerComment(comments, 'plan')?.comment?.body;
+  const ledger = findMarkerComment(comments, 'ledger')?.comment?.body;
+
+  // No plan comment, or a plan with no checkboxes (e.g. a research issue), is
+  // nothing to reconcile — not a violation. No ledger yet is the same.
+  if (!plan || !ledger) return { blocks, warns };
+  const planDone = (plan.match(/^-\s*\[x\]/gim) ?? []).length;
+  const planTotal = planDone + (plan.match(/^-\s*\[ \]/gm) ?? []).length;
+  if (planTotal === 0) return { blocks, warns };
+
+  const completeTasks = new Set();
+  for (const m of ledger.matchAll(/^-\s*Task\s+(\d+):\s*complete\b/gim)) completeTasks.add(m[1]);
+  const ledgerComplete = completeTasks.size;
+
+  if (ledgerComplete > planDone) {
+    blocks.push(`${ledgerComplete} task(s) are marked complete in the ledger but only ${planDone} of ${planTotal} are checked off in the plan comment — tick the matching [x] boxes before hand-back`);
+  }
+  return { blocks, warns };
+}
+
+// Fetch the issue's comments and reconcile plan checkboxes against the ledger.
+// Fails closed: an unreachable gh blocks rather than passing silently.
+function taskConsistencyFromIssue({ issue, repo: repoFlag }) {
+  const repo = repoFlag || ghJson(['repo', 'view', '--json', 'nameWithOwner']).nameWithOwner;
+  const comments = ghJson(['api', `repos/${repo}/issues/${issue}/comments`, '--paginate']);
+  return checkTaskConsistency(comments);
+}
+
 const invokedDirectly = process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url);
 if (invokedDirectly) {
   const flags = parseFlags(process.argv.slice(2));
   let outcome;
   if (!flags.file) {
-    outcome = { blocks: ['usage: evidence-check.mjs --file <evidence.md> [--json]'], warns: [] };
+    outcome = { blocks: ['usage: evidence-check.mjs --file <evidence.md> [--issue <n> --repo <o/r>] [--json]'], warns: [] };
   } else {
     try {
       outcome = checkEvidence(readFileSync(flags.file, 'utf8'));
     } catch (error) {
       outcome = { blocks: [`cannot read evidence: ${error.message}`], warns: [] };
     }
+    // Consistency check only when an issue is named — keeps the file-shape check
+    // network-free by default. A gh failure fails closed onto the block list.
+    if (flags.issue) {
+      try {
+        const consistency = taskConsistencyFromIssue(flags);
+        outcome.blocks.push(...consistency.blocks);
+        outcome.warns.push(...consistency.warns);
+      } catch (error) {
+        outcome.blocks.push(error instanceof GhUnavailable ? `cannot verify plan/ledger consistency: ${error.message}` : `consistency check error: ${error.message}`);
+      }
+    }
   }
   const { exitCode, text } = renderResult('evidence-check', outcome, { json: Boolean(flags.json) });
   console.log(text);

package/skill/dev-implement/scripts/reclaim.mjs

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+// dev-implement reclaim: release an orphaned claim. The operator runs this after
+// dev-status flags a working issue as possibly-orphaned — it resets working →
+// ready and unassigns, so a fresh session can claim it cleanly. It NEVER claims
+// or resumes: a takeover still needs the operator's explicit handover to a new
+// session. It fails closed and refuses to release a claim whose ledger is still
+// fresh (the session may be alive) unless --force is passed.
+//
+// Exit codes: 0 released · 2 refused/blocked (reasons printed). Read-verify runs
+// before any mutation, so a block never leaves a half-released issue.
+// Usage: node reclaim.mjs --issue <n> [--repo o/r] [--orphan-hours 6] [--force] [--json]
+import { execFileSync } from 'node:child_process';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { GhUnavailable, findMarkerComment, ghJson, parseFlags, renderResult } from './lib/gh.mjs';
+
+const WORKING = 'working';
+const READY = 'ready';
+
+const ageHours = (iso, now) => Math.floor((now - Date.parse(iso)) / 3_600_000);
+
+// Read-verify: the deterministic facts that must hold before a release. Returns
+// { blocks, plan } — plan is the mutation to run when blocks is empty.
+export function evaluateReclaim({ issue, comments, orphanHours = 6, force = false, now = Date.now() }) {
+  const blocks = [];
+  const labels = (issue.labels ?? []).map((l) => l.name);
+
+  if (issue.state && issue.state !== 'open') blocks.push(`issue is ${issue.state} — only an open working issue can be reclaimed`);
+  if (!labels.includes(WORKING)) blocks.push(`issue is not '${WORKING}' (labels: [${labels.join(', ') || 'none'}]) — nothing to reclaim`);
+
+  const moved = findMarkerComment(comments, 'ledger')?.comment?.updated_at ?? null;
+  const ageH = moved ? ageHours(moved, now) : null;
+  if (!force && ageH !== null && ageH < orphanHours) {
+    blocks.push(`ledger moved ${ageH}h ago (< orphan threshold ${orphanHours}h) — this claim may be live; pass --force to release anyway`);
+  }
+
+  const assignees = (issue.assignees ?? []).map((a) => a.login);
+  return {
+    blocks,
+    plan: { removeAssignees: assignees, ledgerAgeHours: ageH },
+  };
+}
+
+function ghRun(args) {
+  try {
+    return execFileSync(process.env.VSK_GH || 'gh', args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+  } catch (error) {
+    const stderr = error.stderr?.toString().trim() || error.message;
+    throw new GhUnavailable(`gh ${args.join(' ')} failed: ${stderr}`);
+  }
+}
+
+export function gatherAndReclaim(flags) {
+  const repo = flags.repo || ghJson(['repo', 'view', '--json', 'nameWithOwner']).nameWithOwner;
+  const issueNumber = flags.issue;
+  const raw = ghJson(['api', `repos/${repo}/issues/${issueNumber}`]);
+  const comments = ghJson(['api', `repos/${repo}/issues/${issueNumber}/comments`, '--paginate']);
+  const orphanRaw = Number(flags['orphan-hours']);
+  const { blocks, plan } = evaluateReclaim({
+    issue: { state: raw.state, labels: raw.labels, assignees: raw.assignees },
+    comments,
+    orphanHours: Number.isFinite(orphanRaw) && orphanRaw >= 1 ? orphanRaw : 6,
+    force: Boolean(flags.force),
+  });
+  if (blocks.length > 0) return { blocks, warns: [] };
+
+  // Mutations, only past a clean read-verify. Label swap first (frees the
+  // claim), then unassign, then the operator-visible note.
+  ghRun(['issue', 'edit', String(issueNumber), '-R', repo, '--remove-label', WORKING, '--add-label', READY]);
+  for (const login of plan.removeAssignees) {
+    ghRun(['issue', 'edit', String(issueNumber), '-R', repo, '--remove-assignee', login]);
+  }
+  const age = plan.ledgerAgeHours === null ? 'no ledger comment was ever written' : `ledger silent ${plan.ledgerAgeHours}h`;
+  const note = `**Claim released.** \`${WORKING}\` → \`${READY}\`, unassigned — ${age}. The prior session did not hand back; its branch and ledger stand. Resume it (dev-implement, the operator's handover) or let a fresh session claim it.`;
+  ghRun(['issue', 'comment', String(issueNumber), '-R', repo, '--body', note]);
+  return { blocks: [], warns: [`released #${issueNumber}: ${WORKING} → ${READY}, unassigned (${age})`] };
+}
+
+const invokedDirectly = process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (invokedDirectly) {
+  const flags = parseFlags(process.argv.slice(2), ['json', 'force']);
+  let outcome;
+  if (!flags.issue) {
+    outcome = { blocks: ['usage: reclaim.mjs --issue <n> [--repo o/r] [--orphan-hours 6] [--force] [--json]'], warns: [] };
+  } else {
+    try {
+      outcome = gatherAndReclaim(flags);
+    } catch (error) {
+      outcome = { blocks: [error instanceof GhUnavailable ? `cannot verify: ${error.message}` : `reclaim error: ${error.message}`], warns: [] };
+    }
+  }
+  const { exitCode, text } = renderResult('reclaim', outcome, { json: Boolean(flags.json) });
+  console.log(text);
+  process.exit(exitCode);
+}

package/skill/dev-status/SKILL.md

@@ -12,10 +12,10 @@ Nearest neighbors: `dev-chronicle` answers "how did we get here"; this skill ans
 ## Gather
 
 ```
-node <path-to-this-skill>/scripts/status.mjs --stale-days 3 --json
+node <path-to-this-skill>/scripts/status.mjs --orphan-hours 6 --json
 ```
 
-Read-only; it returns the board (open issues per state label with age, scope, risky), task progress `x/y` from plan-comment checkboxes, ledger movement for `working` issues (stale = no ledger edit within `--stale-days`, default 3), open PRs with check state, pending unrecorded `Decision:` proposals, and the last chronicle entry. Exit 2 = cannot verify (offline, unauthenticated) — report the gap plainly and stop; never render a guessed board.
+Read-only; it returns the board (open issues per state label with age, scope, risky), task progress `x/y` from plan-comment checkboxes, ledger movement for `working` issues in hours (`possiblyOrphaned` = the ledger has been silent past `--orphan-hours`, default 6, or was never written — the claim's heartbeat has stopped), open PRs with check state, pending unrecorded `Decision:` proposals, and the last chronicle entry. Exit 2 = cannot verify (offline, unauthenticated) — report the gap plainly and stop; never render a guessed board.
 
 ## Render — names, never bare numbers
 
@@ -26,8 +26,8 @@ Needs you (N):
 - <linked title> — <state> <age>d: <one line: what it waits for and the word needed>
 Waiting on plan (N): - <linked title> — needs-plan <age>d
 Ready to build (N): - <linked title> — <scope>
-In flight (N): - <linked title> — working, task <x>/<y>, ledger moved <n>d ago
-Stale (N): - <linked title> — working <age>d, ledger silent <n>d → check or reclaim
+In flight (N): - <linked title> — working, task <x>/<y>, ledger moved <n>h ago
+Possibly orphaned (N): - <linked title> — working <age>d, ledger silent <n>h → heartbeat stopped; check, resume, or reclaim (`reclaim.mjs --issue <n>`)
 Open PRs (N): - <linked title> — checks <green|pending-or-red|no-checks>
 Pending decisions (N): "<gist-plain>" (<linked issue>) — records at that issue's merge
 Last chronicle chapter: <date> — <title-plain>
@@ -38,9 +38,10 @@ Next: <the single most valuable operator action, and why>
 - Sections with zero entries are omitted, not rendered empty. A completely quiet board is one line: "Nothing needs you — <n> issues ready for agents, nothing in flight."
 - `risky` issues get their flag shown inline wherever they appear.
 - **Next** is one line, chosen not computed-looking: the action that unblocks the most (a plan approval blocking several ready issues beats a lone review).
+- **Possibly orphaned** is the ledger heartbeat gone silent past the orphan window (or never started) — likely a dead session, not certainly one. Surface it with the `reclaim.mjs` command inline; the operator decides (check the session, hand it to a resume, or release the claim). A long-running task that keeps checkpointing never lands here.
 - <linked title> means a markdown link this report builds around the issue/PR title and its URL; numbers ride inside the link, never stand alone. That governs the references the board itself makes.
 - `<title-plain>` / `<gist-plain>` are the script's `titlePlain` / `gistPlain` fields — text quoted from elsewhere (a chronicle title, a decision gist) may arrive carrying markdown links, and raw bracket-and-parenthesis markup means nothing in a terminal, so it is quoted with the markup removed rather than relinked.
 
 ## Honesty rules
 
-Data comes only from the script; ordering, the wait-reason one-liners, and Next are the skill's judgment — clearly judgment, never dressed as data. A stale `working` issue is a fact to surface, not an accusation: "check or reclaim" is the operator's call (a takeover still needs their explicit handover, per dev-implement). Close with the plain-language summary only when invoked as part of a larger run; standalone, the report IS the summary.
+Data comes only from the script; ordering, the wait-reason one-liners, and Next are the skill's judgment — clearly judgment, never dressed as data. A possibly-orphaned `working` issue is a fact to surface, not an accusation — the ledger heartbeat went silent, which is likely but not certainly a dead session: "check, resume, or reclaim" is the operator's call (a takeover still needs their explicit handover, and `reclaim.mjs` is theirs to run, per dev-implement). Close with the plain-language summary only when invoked as part of a larger run; standalone, the report IS the summary.

package/skill/dev-status/scripts/status.mjs

@@ -2,7 +2,7 @@
 // dev-status data gatherer: everything the board report needs, deterministically,
 // read-only, markers-only. The skill renders; this script never invents state.
 //
-// Usage: node status.mjs [--repo o/r] [--stale-days 3] [--dev-md <path>] --json
+// Usage: node status.mjs [--repo o/r] [--orphan-hours 6] [--dev-md <path>] --json
 import { execFileSync } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
@@ -46,6 +46,15 @@ export function ageDays(iso, now = Date.now()) {
   return Math.floor((now - Date.parse(iso)) / 86_400_000);
 }
 
+// Ledger liveness is measured in hours, not days: a session that hands back in
+// hours can go dark for a fraction of a day, which whole-day granularity cannot
+// even represent. The ledger's updated_at is the only liveness proxy an agent
+// session exposes — a live session (even a multi-day one) checkpoints and keeps
+// this small; a dead one freezes it.
+export function ageHours(iso, now = Date.now()) {
+  return Math.floor((now - Date.parse(iso)) / 3_600_000);
+}
+
 export function parseMarker(body) {
   const match = /<!--\s*vsk:v1\s+([^>]*?)\s*-->/.exec(body ?? '');
   if (!match) return null;
@@ -110,7 +119,7 @@ export function checksState(rollup) {
   return rollup.every(ok) ? 'green' : 'pending-or-red';
 }
 
-export function gatherStatus({ repo, staleDays = 3, devMdPath = '.vegastack/dev.md', chroniclePath = '.vegastack/chronicle.md', now = Date.now() } = {}) {
+export function gatherStatus({ repo, orphanHours = 6, devMdPath = '.vegastack/dev.md', chroniclePath = '.vegastack/chronicle.md', now = Date.now() } = {}) {
   const resolvedRepo = repo || gh(['repo', 'view', '--json', 'nameWithOwner']).nameWithOwner;
   const devMdText = existsSync(devMdPath) ? readFileSync(devMdPath, 'utf8') : '';
   const knobs = readKnobs(devMdText);
@@ -133,8 +142,12 @@ export function gatherStatus({ repo, staleDays = 3, devMdPath = '.vegastack/dev.
       const comments = gh(['api', `repos/${resolvedRepo}/issues/${issue.number}/comments`, '--paginate']);
       issue.tasks = taskProgress(comments);
       const moved = ledgerMovedAt(comments);
-      issue.ledgerAgeDays = moved ? ageDays(moved, now) : null;
-      issue.stale = bucket === knobs.states[3] && (issue.ledgerAgeDays === null || issue.ledgerAgeDays >= staleDays);
+      issue.ledgerAgeHours = moved ? ageHours(moved, now) : null;
+      // possiblyOrphaned: a working issue whose ledger has been silent past the
+      // orphan threshold — or which never got a ledger comment at all (claimed,
+      // then died before its first write). A fact for the operator to act on,
+      // never an automatic reclaim: the reset is theirs to run.
+      issue.possiblyOrphaned = bucket === knobs.states[3] && (issue.ledgerAgeHours === null || issue.ledgerAgeHours >= orphanHours);
       decisions.push(...pendingDecisions(comments, registerText).map((d) => ({ issue: issue.number, gist: d, gistPlain: stripLinks(d) })));
     }
   }
@@ -151,7 +164,7 @@ export function gatherStatus({ repo, staleDays = 3, devMdPath = '.vegastack/dev.
     if (m) lastChronicle = { date: m[1], title: m[2], titlePlain: stripLinks(m[2]) };
   }
 
-  return { repo: resolvedRepo, staleDays, board, prs, pendingDecisions: decisions, lastChronicle };
+  return { repo: resolvedRepo, orphanHours, board, prs, pendingDecisions: decisions, lastChronicle };
 }
 
 const invokedDirectly = process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url);
@@ -159,8 +172,8 @@ if (invokedDirectly) {
   const argv = process.argv.slice(2);
   const get = (f) => { const i = argv.indexOf(f); return i === -1 ? undefined : argv[i + 1]; };
   try {
-    const staleDaysRaw = Number(get('--stale-days'));
-    const data = gatherStatus({ repo: get('--repo'), staleDays: Number.isFinite(staleDaysRaw) && staleDaysRaw >= 1 ? staleDaysRaw : 3, devMdPath: get('--dev-md') });
+    const orphanRaw = Number(get('--orphan-hours'));
+    const data = gatherStatus({ repo: get('--repo'), orphanHours: Number.isFinite(orphanRaw) && orphanRaw >= 1 ? orphanRaw : 6, devMdPath: get('--dev-md') });
     console.log(JSON.stringify(data, null, argv.includes('--json') ? 2 : 0));
   } catch (error) {
     console.error(`status: cannot verify — ${error.message}`);

package/skill-integrity.json

@@ -48,15 +48,16 @@
       "group": "dev-skills",
       "repoOnly": false,
       "files": {
-        "SKILL.md": "f79f4d312f6c03ffdcf2e2fd44169e48520445900389e2d469c0946811be3801",
+        "SKILL.md": "1b38469b3fc0feedf8650ad1f9bfda35485406dc81de89a66e5ab57c670bc798",
         "agents/openai.yaml": "1abab383deca54d32749fd9156f9a6211fe96e02e0166dc8a16ff8459ac31b74",
         "references/conventions.md": "95bf916cc11f95f3d5eefcb34db4fbc05d88ae1c8f08869800dfa417f8da17ed",
-        "references/ledger-and-resume.md": "5e3deae2af67735940564e04adcbc23c0c0dc86da2f6c80d68b8c1207c8f5900",
+        "references/ledger-and-resume.md": "974fe4895973aca4ce05ad3eca05c71f1bbb518a59027732c459cc3331fb2f98",
         "refresh/REFRESH.md": "7b854109d897b78b3055bf1ab89517afdca65c12eb65a4d009141e3ee11cf58f",
         "refresh/sources.json": "7bd883e5b3512e236a909ad6ff20c97f3555785867c31fd728256c7c2c514c74",
-        "scripts/evidence-check.mjs": "9a360e6c5460d46b271b28457ee6be92f165c54c771c2dc6860c4a52e6890a9a",
+        "scripts/evidence-check.mjs": "974e343ae5372e8b3c930d4ba05e48b29ea5204048f9d2c3cdc8b89237933d8c",
         "scripts/lib/gh.mjs": "d2261e4b3e2d7b3cdc58123b1503c0264664d7e5a258e90d0caa79333466975a",
-        "scripts/preflight.mjs": "1bf47b6d147c8603e28d96f7c81f2b4db61b60a3811190ca96b36d83129820d5"
+        "scripts/preflight.mjs": "1bf47b6d147c8603e28d96f7c81f2b4db61b60a3811190ca96b36d83129820d5",
+        "scripts/reclaim.mjs": "fea8299765ded7052a724e55399f40a1769d91f218df7c38922859800065fa73"
       }
     },
     "dev-intake": {
@@ -134,12 +135,12 @@
       "group": "dev-skills",
       "repoOnly": false,
       "files": {
-        "SKILL.md": "56415c2f69bb1a2fcb488b9846a20e632eb902b05c5b2b58ae9206d3eaffd77b",
+        "SKILL.md": "1e4742805f8f6c99f36e3eea4171b39e336d14aad001d5309b507bf6efa40ae7",
         "agents/openai.yaml": "72435947f5afef0c8a2c170e987b14fe6057b174318c16b6b538ae8d129791fb",
         "references/conventions.md": "95bf916cc11f95f3d5eefcb34db4fbc05d88ae1c8f08869800dfa417f8da17ed",
         "refresh/REFRESH.md": "52aee9bae64d8342e127704d1db282e43ed57c101148727bf10172d6cb975bfa",
         "refresh/sources.json": "a7ba2340964dc70410626087686145b5790a0e763a18ef2c4d9aa37e950f2e04",
-        "scripts/status.mjs": "bc56d0b5d996676cfccb752d9d77d0e9e7d64932741cd39d6a503e9761fbe34d"
+        "scripts/status.mjs": "f6672ef38cbe31a2335633a96567977d9b885390f1f766bf63f6dd7d172c987b"
       }
     },
     "skill-maintainer": {