lobstah 0.3.1 → 0.3.2

package/dist/main.js

@@ -1957,6 +1957,12 @@ var PickupState = class {
     this.data.map[key] = { ...cur, ...patch };
     this.save();
   }
+  releaseIssue(key) {
+    const entry = this.get(key);
+    if (entry?.kind !== "issue" || entry.lastReported !== "failed")
+      return;
+    this.update(key, { released: true, attempts: entry.attempts ?? 1 });
+  }
   approvalConsumed(dedupKey) {
     return dedupKey in this.data.consumedApprovals;
   }
@@ -2242,6 +2248,7 @@ When the change is complete, commit it, push the branch, and open a PR against $
 
 // apps/pick/dist/sources/linear.js
 var API2 = "https://api.linear.app/graphql";
+var CLOSED_TYPES = ["completed", "canceled"];
 function stateFor(cfg, verb) {
   if (verb === "done")
     return cfg.doneState;
@@ -2268,15 +2275,22 @@ var LinearSource = class {
     }
     return json.data;
   }
-  async assigned(stateName, byTypes) {
+  async assigned(filter) {
     const field = this.cfg.assignField ?? "assignee";
-    const stateFilter = byTypes?.length ? { type: { in: byTypes } } : { name: { eq: stateName } };
-    const data = await this.gql(`query($filter: IssueFilter!) {
-        issues(filter: $filter, first: 50) {
-          nodes { id identifier title description state { name type } team { key id } }
-        }
-      }`, { filter: { [field]: { isMe: { eq: true } }, state: stateFilter } });
-    return data.issues.nodes;
+    const issues = [];
+    let after = null;
+    for (; ; ) {
+      const data = await this.gql(`query($filter: IssueFilter!, $after: String) {
+          issues(filter: $filter, first: 50, after: $after) {
+            nodes { id identifier title description state { name type } team { key id } }
+            pageInfo { hasNextPage endCursor }
+          }
+        }`, { filter: { [field]: { isMe: { eq: true } }, ...filter }, after });
+      issues.push(...data.issues.nodes);
+      if (!data.issues.pageInfo.hasNextPage)
+        return issues;
+      after = data.issues.pageInfo.endCursor;
+    }
   }
   async stateId(teamId, name) {
     const cacheKey = `${teamId}:${name}`;
@@ -2304,7 +2318,8 @@ var LinearSource = class {
     await this.gql(`mutation($id: String!, $body: String!) { commentCreate(input: { issueId: $id, body: $body }) { success } }`, { id: issue.id, body });
   }
   async poll() {
-    const issues = await this.assigned(this.cfg.startState, this.cfg.startStateTypes);
+    const state = this.cfg.startStateTypes?.length ? { type: { in: this.cfg.startStateTypes } } : { name: { eq: this.cfg.startState } };
+    const issues = await this.assigned({ state });
     return issues.flatMap((issue) => {
       const repoKey = this.cfg.route[issue.team.key];
       if (!repoKey)
@@ -2343,7 +2358,7 @@ When the change is complete, commit it, push the branch, and open a PR whose des
       lines.push(evidence.note);
     await this.commentOn(issue, lines.join("\n"));
     const target = stateFor(this.cfg, verb);
-    if (target)
+    if (target && !CLOSED_TYPES.includes(issue.state.type))
       await this.moveTo(issue, target);
   }
   async inbound(key, since) {
@@ -2352,8 +2367,10 @@ When the change is complete, commit it, push the branch, and open a PR whose des
     return data.issue.comments.nodes.filter((c) => !c.user?.isMe && !MARKER.test(c.body)).filter((c) => !since || c.createdAt > since).map((c) => c.body);
   }
   async inProgress() {
-    const issues = await this.assigned(this.cfg.claimedState);
-    return issues.map((i) => ({ key: `linear:${i.identifier}`, open: true }));
+    const issues = await this.assigned({
+      or: [{ state: { name: { eq: this.cfg.claimedState } } }, { state: { type: { in: CLOSED_TYPES } } }]
+    });
+    return issues.map((i) => ({ key: `linear:${i.identifier}`, open: !CLOSED_TYPES.includes(i.state.type) }));
   }
   async recoverUuid(key) {
     const identifier = key.replace(/^linear:/, "");
@@ -2391,6 +2408,8 @@ async function reportLoop(source, state, log = () => {
 }, notify = () => {
 }) {
   for (const [key, entry] of state.entries()) {
+    if (entry.released)
+      continue;
     const lane = dispatchLane(entry.uuid);
     if (!lane)
       continue;
@@ -2411,6 +2430,11 @@ async function reportLoop(source, state, log = () => {
         prUrl: evidence.prUrl
       });
     }
+    if (entry.kind === "issue" && verb === "failed" && fs17.existsSync(path12.join(laneDirs(lane).done, entry.uuid))) {
+      state.releaseIssue(key);
+      log(`${key}: finalized failure released for a bounded retry`);
+      continue;
+    }
     const msgs = await source.inbound(key, entry.lastInboundAt);
     if (msgs.length > 0) {
       for (const m of msgs)
@@ -2441,9 +2465,17 @@ function roundPlan(item, state) {
 async function dispatchLoop(source, state, log = () => {
 }) {
   const items = await source.poll();
+  const maxAttempts = 1 + loadConfig().limits.maxRestartAttempts;
   for (const item of items) {
-    if (state.get(item.key))
-      continue;
+    const previous = state.get(item.key);
+    if (previous) {
+      if (item.kind !== "issue" || previous.kind !== "issue" || !previous.released)
+        continue;
+      if ((previous.attempts ?? 1) >= maxAttempts) {
+        log(`${item.key}: issue attempt limit (${maxAttempts}) reached \u2014 holding for a human`);
+        continue;
+      }
+    }
     const plan = item.kind === "review" ? roundPlan(item, state) : { hold: false, followUp: void 0 };
     if (plan.hold) {
       log(`${item.key}: a prior round is still in flight \u2014 holding`);
@@ -2461,7 +2493,12 @@ async function dispatchLoop(source, state, log = () => {
       // A review dispatch forks the latest session in its chain; issues start cold.
       ...plan.followUp ? { followUp: plan.followUp } : {}
     }, "work");
-    state.set(item.key, { uuid: id, kind: item.kind, createdAt: (/* @__PURE__ */ new Date()).toISOString() });
+    state.set(item.key, {
+      uuid: id,
+      kind: item.kind,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...item.kind === "issue" ? { attempts: previous ? (previous.attempts ?? 1) + 1 : 1 } : {}
+    });
     log(`${item.key}: dispatched as ${id}`);
   }
 }

package/docs/lobsterman.md

@@ -125,6 +125,18 @@ After dispatching work, run `lobstah man wait` as a background task. When it
 completes, follow its `next:` instruction, then re-arm it.
 ```
 
+**Arm it long-lived.** The default (`--timeout 0`) waits forever and returns
+only when something happens — that is the right idiom, not a compromise.
+Every wake costs the session a turn, so a short timeout used as a "check in
+periodically" mechanism buys nothing but noise: attention is level-triggered
+and stands on disk until consumed, so a wait that dies mid-shift drops zero
+events — the next wait delivers everything that accumulated. There is no
+report to miss either; a quiet fleet has nothing to say. Pass `--timeout`
+only as a dead-man's check on the channel itself (an hour, not minutes): a
+quiet timeout prints one line, exits 3, and the re-arm proves the line was
+alive. Liveness reassurance for the human belongs on a status surface
+(`lobstah man tend`), never in the transcript.
+
 **Tier 3 — park the session on a Stop hook (Claude Code only).** A Stop hook
 that blocks on `lobstah man wait`, so the session never
 really idles — it parks for free and continues the moment something needs it.

package/docs/pickup.md

@@ -300,6 +300,19 @@ An orphan verdict requires a trustworthy mapping — see
 [Pickup state](#pickup-state): a missing table entry is `unknown` and triggers
 a rebuild, never a reset.
 
+Linear reconciliation includes assigned/delegated issues in the claimed state
+and terminal (`completed`/`canceled`) states, following every results page.
+A failure report leaves an already closed Linear issue closed.
+
+After an issue dispatch finalizes as `failed` and its tracker report succeeds,
+pickup releases its key for another claim when the tracker offers it in the
+start state. The ledger retains the last UUID and an attempt count across
+restarts: one initial attempt plus `[limits].maxRestartAttempts` retries
+(default two). Legacy entries count as one attempt. At the cap, the issue stays
+in the start state for human attention; polling does not claim it again.
+Successful dispatches and review-round keys remain deduplicated. A `done`
+report alone is not a failure verdict, regardless of commit count.
+
 **Residual, by honesty:** same-machine reconciliation cannot detect
 whole-machine death — the reconciler dies with the laptop. The stale
 `executor.json` heartbeat covers that case, but only for a remote reader — a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lobstah",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "Harness-agnostic, token-efficient supervision framework for coding agents",
   "license": "MIT",
   "author": "aequitas labs LLC",