@bivy/bivy 0.6.0-staging.86 → 0.6.0-staging.87

package/dist/server.js

@@ -5225,6 +5225,47 @@ async function resolveTokenForRepo(owner, repo) {
     }
     return (await resolveGitHubToken()) ?? (await hostedMintToken());
 }
+/** The session source a Linear-issue pickup advertises, keyed by the issue's
+ *  provider-native id so the control plane can correlate a re-dispatch to it
+ *  (findSessionByExternalId → "linear:<externalId>"). The Linear analogue of the
+ *  GitHub `issue:owner/repo#N` source. */
+function linearSessionSource(externalId) {
+    return `linear:${externalId}`;
+}
+/**
+ * Case B for a queued follow-up the control plane correlated to an existing
+ * session (`targetKind === "existing_session"`): if that session is still live on
+ * this node, continue it as a normal chat — run `prompt` as a follow-up turn and
+ * re-publish its branch/PR — so a channel reply lands in the same thread. The
+ * provider-agnostic analogue of the GitHub issue follow-up (`runIssueFollowUp`);
+ * used by both the Linear and the generic (Slack) pickup paths. When the session
+ * isn't live here (its machine was torn down), best-effort restore its snapshot so
+ * the caller's fresh pickup continues its branch/transcript instead of cold-
+ * starting, and return false so the caller falls through. Returns true only when
+ * it fully handled the item.
+ */
+async function continueCorrelatedSession(item, prompt, report) {
+    if (item.targetKind !== "existing_session" || !item.targetSessionId)
+        return false;
+    const record = openSessions.get(item.targetSessionId);
+    if (!record) {
+        await restoreSessionFromSnapshot(item.targetSessionId).catch((e) => console.warn(`[case-b] snapshot restore for ${item.targetSessionId} failed:`, e.message));
+        return false;
+    }
+    const branch = record.worktree?.branch;
+    await runSessionTurn(record, prompt);
+    if (record.worktree) {
+        await maybePushWorktreeBranch(record);
+        await maybeDetectPullRequest(record);
+    }
+    await report({
+        output: { sessionId: record.id, branch, prUrl: record.prUrl },
+        events: record.prUrl
+            ? [{ at: new Date().toISOString(), kind: "pull_request", summary: "Pull request updated.", ref: branch, url: record.prUrl }]
+            : undefined,
+    });
+    return true;
+}
 async function runWorkItem(item, report) {
     if ((item.source === "schedule" || item.source === "manual") && item.body?.startsWith("bivy-room-v1:")) {
         const [, nodeId, ...payload] = item.body.split(":");
@@ -5303,6 +5344,10 @@ async function runWorkItem(item, report) {
         const parsed = parseRepo(repoSlug);
         if (!parsed)
             throw new Error(`Linear work item has an invalid repo "${repoSlug}"`);
+        // Case B: a re-dispatch the control plane correlated to an existing session
+        // continues it as a normal chat instead of starting cold (mirrors GitHub).
+        if (await continueCorrelatedSession(item, buildLinearTaskPrompt(issue), report))
+            return;
         const githubToken = await resolveGitHubToken();
         if (!githubToken)
             throw new Error("no GitHub token available to clone the Linear issue repository");
@@ -5313,7 +5358,7 @@ async function runWorkItem(item, report) {
         const record = await createSession(repoDir, undefined, {
             worktree: { branch, base },
             makeActive: false,
-            source: "queue:linear:issue",
+            source: linearSessionSource(item.externalId),
             runtimeId: item.runtimeId || nodeConfiguredDefaultAgent(),
             sandbox: normalizeSandboxTier(item.sandbox),
             approvalMode: approvalModeFrom(item.approvalMode),
@@ -5339,6 +5384,13 @@ async function runWorkItem(item, report) {
     const parsedRepo = item.repo ? parseRepo(item.repo) : undefined;
     if (item.repo && !parsedRepo)
         throw new Error(`work item ${item.id} has an invalid repo "${item.repo}"`);
+    const request = item.body ? `${item.title}\n\n${item.body}` : item.title;
+    // Case B (provider-agnostic): a follow-up the control plane correlated to an
+    // existing session continues it as a normal chat. Reached by Slack the moment a
+    // reply carries a thread identity the control plane can correlate; a one-shot
+    // slash command has none, so it simply falls through to a fresh session.
+    if (await continueCorrelatedSession(item, request, report))
+        return;
     const sessionOpts = {
         makeActive: false,
         title: item.title,
@@ -5359,7 +5411,6 @@ async function runWorkItem(item, report) {
         }
         catch { }
     }
-    const request = item.body ? `${item.title}\n\n${item.body}` : item.title;
     const prompt = parsedRepo || record.worktree
         ? [
             request,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bivy/bivy",
-  "version": "0.6.0-staging.86",
+  "version": "0.6.0-staging.87",
   "type": "module",
   "license": "FSL-1.1-ALv2",
   "description": "Run coding agents on machines you own. Source-available, self-hostable agent workspace.",