@agent-relay/factory 0.1.15 → 0.1.17

package/dist/orchestrator/factory.js

@@ -156,6 +156,7 @@ export class FactoryLoop {
     // Issue key -> the open PR the babysitter is shepherding, including the
     // webhook-fed mount path so readiness can re-read PR meta without a gh call.
     #babysitterPr = new Map();
+    #publishedPullRequests = new Set();
     #probePrGhBackoffUntilMs = new Map();
     #probePrResolvedCache = new Map();
     // GitHub issue mirror-id -> resolved Linear mirror path, so repeat ingestion
@@ -2195,6 +2196,19 @@ export class FactoryLoop {
         }
         const exiting = record.agents.get(name);
         if (isCompletionReason(reason)) {
+            let publishedPr;
+            if (exiting?.spec.role === 'implementer' &&
+                !record.dryRun &&
+                (this.#mount.githubWrite || this.#mount.writebackTransport === 'relayfile-cloud')) {
+                try {
+                    publishedPr = await this.#publishImplementerPullRequest(record, exiting);
+                }
+                catch (error) {
+                    this.#increment('githubPullRequestPublishFailures');
+                    this.#error(error, record.issue);
+                    return;
+                }
+            }
             if (this.#config.babysitter.enabled && !record.dryRun) {
                 // Babysitter path: an implementer/reviewer finishing does NOT mark the
                 // issue done — it hands the open PR to the babysitter. The babysitter
@@ -2203,6 +2217,13 @@ export class FactoryLoop {
                 if (exiting?.spec.role === 'babysitter') {
                     await this.#maybeAdvanceToHumanReview(record);
                 }
+                else if (publishedPr) {
+                    await this.#ensureBabysitter(record, {
+                        repo: publishedPr.repo,
+                        prNumber: publishedPr.number,
+                        url: publishedPr.url,
+                    });
+                }
                 else {
                     await this.#ensureBabysitterForIssue(record);
                 }
@@ -2224,14 +2245,40 @@ export class FactoryLoop {
                 await this.#completeIssue(record);
                 return;
             }
+            // The implementer's turn ended without a PR of record. Agents reliably
+            // COMMIT their work to a feature branch but often exit (turn-end / idle)
+            // before running `gh pr create` — the root reason a dispatch never reached
+            // human-review even after the #67 fixes. Rather than respawn a done agent
+            // and hope, factory finalizes the branch into a PR itself (the same
+            // publish path the completion flow uses), then advances to the babysitter
+            // / human-review path. Best-effort: with no publishable branch (no commits
+            // ahead of base, clone gone) it returns undefined and we fall through.
+            if (tracked.spec.role === 'implementer') {
+                const publishedPr = await this.#tryPublishImplementerPr(record, tracked);
+                if (publishedPr) {
+                    if (this.#config.babysitter.enabled) {
+                        await this.#ensureBabysitter(record, {
+                            repo: publishedPr.repo,
+                            prNumber: publishedPr.number,
+                            url: publishedPr.url,
+                        });
+                    }
+                    else {
+                        await this.#completeIssue(record);
+                    }
+                    return;
+                }
+            }
             if (tracked.sessionRef) {
                 const resumeKey = `${issueKey(record.issue)}:${name}:${tracked.sessionRef}`;
                 if (await this.#state.isResumed(this.#workspaceId, resumeKey)) {
                     // Already resumed once and STILL exiting with no completion PR — the
-                    // agent isn't making progress. Escalate so a human notices, instead of
-                    // leaving the issue silently in-flight forever.
+                    // agent isn't making progress. Conclude the dispatch so a human
+                    // notices AND the reviewer waiting on the implementer's DM is torn
+                    // down, instead of leaving the issue silently in-flight forever with
+                    // a live reviewer stalling the owned-broker dispose-wait (#67).
                     if (tracked.spec.role === 'implementer') {
-                        await this.#escalateStalledIssue(record, name);
+                        await this.#concludeTerminalImplementer(record, name, 'stalled-no-pr');
                     }
                     return;
                 }
@@ -2250,17 +2297,24 @@ export class FactoryLoop {
                     if (isAgentAlreadyExistsError(error)) {
                         // The broker never released this agent's name on exit
                         // (relay#1116-family), so re-registering collides with the stuck
-                        // name. The error is marked retryable but isn't — retrying just
-                        // re-collides forever. Treat it as terminal for this name: record
-                        // the resume key so subsequent exit events short-circuit, count it,
-                        // and warn once instead of spamming a 500 stack trace. The external
-                        // reaper / a broker restart reclaims the leaked name.
+                        // name. Retrying just re-collides forever. Treat it as terminal for
+                        // this name: record the resume key so subsequent exit events
+                        // short-circuit, count it, and warn once. The external reaper / a
+                        // broker restart reclaims the leaked name.
+                        this.#fleet.markAgentTerminal?.(name, 'resume-already-exists');
                         await this.#state.markResumed(this.#workspaceId, resumeKey);
                         this.#increment('resumeNameCollisions');
                         this.#logger.warn?.('[factory] resume skipped: broker still holds agent name (relay#1116); not retrying', {
                             issue: record.issue.key,
                             name,
                         });
+                        // The implementer is now terminal but never sent the completion DM
+                        // the reviewer is blocked on ("Wait for a DM from the
+                        // implementer(s)"). Resolve the dispatch so the reviewer does not
+                        // stay live forever and stall the owned-broker dispose-wait (#67).
+                        if (tracked.spec.role === 'implementer') {
+                            await this.#concludeTerminalImplementer(record, name, 'resume-already-exists');
+                        }
                     }
                     else {
                         throw error;
@@ -2272,25 +2326,141 @@ export class FactoryLoop {
             }
             else {
                 const invocationId = `${batch.invocationIdFor(record.issue, tracked.spec)}:restart:${this.#clock.now()}`;
-                const result = await this.#fleet.spawn({
-                    name: tracked.spec.name,
-                    capability: tracked.spec.capability,
-                    node: tracked.spec.node ?? 'self',
-                    task: tracked.spec.task,
-                    model: tracked.spec.model,
-                    cwd: tracked.spec.clonePath,
-                    sessionRef: tracked.spec.sessionRef,
-                    invocationId,
-                    restartPolicy: defaultRestartPolicy(tracked.spec),
-                    channel: tracked.spec.channel,
-                });
-                batch.recordSpawn(record, tracked.spec, invocationId, result);
+                try {
+                    const result = await this.#fleet.spawn({
+                        name: tracked.spec.name,
+                        capability: tracked.spec.capability,
+                        node: tracked.spec.node ?? 'self',
+                        task: tracked.spec.task,
+                        model: tracked.spec.model,
+                        cwd: tracked.spec.clonePath,
+                        sessionRef: tracked.spec.sessionRef,
+                        invocationId,
+                        restartPolicy: defaultRestartPolicy(tracked.spec),
+                        channel: tracked.spec.channel,
+                    });
+                    batch.recordSpawn(record, tracked.spec, invocationId, result);
+                }
+                catch (error) {
+                    if (!isAgentAlreadyExistsError(error)) {
+                        throw error;
+                    }
+                    // Same leaked-broker-name collision as the resume path, on a
+                    // no-sessionRef respawn: the broker's own restartPolicy already
+                    // re-registered the name (relay#1116-family), so our respawn collides.
+                    // Retrying just re-collides forever. Treat it as terminal and resolve
+                    // the dispatch so a reviewer blocked on the implementer's DM does not
+                    // hang the owned-broker dispose-wait (#67).
+                    this.#fleet.markAgentTerminal?.(name, 'respawn-already-exists');
+                    this.#increment('resumeNameCollisions');
+                    this.#logger.warn?.('[factory] respawn skipped: broker still holds agent name (relay#1116); not retrying', {
+                        issue: record.issue.key,
+                        name,
+                    });
+                    if (tracked.spec.role === 'implementer') {
+                        await this.#concludeTerminalImplementer(record, name, 'respawn-already-exists');
+                    }
+                }
             }
         }
         catch (error) {
             this.#error(error, record.issue);
         }
     }
+    // Publish a PR from the implementer's committed branch when it exited without
+    // opening one. Best-effort and idempotent: returns undefined when there is no
+    // GitHub write path, no clone, or nothing publishable (no branch / no commits
+    // ahead of base — `#publishImplementerPullRequest` refuses head==base), so the
+    // caller falls back to its normal restart/conclude handling.
+    async #tryPublishImplementerPr(record, implementer) {
+        if (record.dryRun || !implementer.spec.clonePath || !this.#mount.githubWrite) {
+            return undefined;
+        }
+        try {
+            const published = await this.#publishImplementerPullRequest(record, implementer);
+            if (published) {
+                this.#increment('implementerPrsPublishedOnExit');
+                this.#logger.info?.('[factory] published PR from implementer clone after it exited without opening one', {
+                    issue: record.issue.key,
+                    repo: published.repo,
+                    prNumber: published.number,
+                });
+            }
+            return published;
+        }
+        catch (error) {
+            this.#increment('exitPrPublishSkipped');
+            this.#logger.warn?.('[factory] could not publish implementer PR on exit; falling back', {
+                issue: record.issue.key,
+                name: implementer.result?.name ?? implementer.spec.name,
+                error: describeError(error).errorMessage,
+            });
+            return undefined;
+        }
+    }
+    async #publishImplementerPullRequest(record, implementer) {
+        const key = `${issueKey(record.issue)}:${implementer.spec.repo}`;
+        if (this.#publishedPullRequests.has(key))
+            return undefined;
+        const githubWrite = this.#mount.githubWrite;
+        if (!githubWrite) {
+            throw new Error('GitHub write path not available on this mount — connect GitHub to your workspace');
+        }
+        if (!implementer.spec.clonePath) {
+            throw new Error(`GitHub PR publication requires a configured clone path for ${implementer.spec.repo}`);
+        }
+        const issue = await this.#readIssue(record.issue.path);
+        if (!issue) {
+            throw new Error(`Unable to publish GitHub PR: issue ${record.issue.key} is no longer readable`);
+        }
+        const sourceRepo = githubMirrorRepoForIssue(issue);
+        const sourceRepoParts = sourceRepo ? githubRepoParts(sourceRepo) : undefined;
+        const bareRepoName = implementer.spec.repo.includes('/') ? undefined : implementer.spec.repo;
+        const sourceOwner = bareRepoName && sourceRepoParts?.repo === bareRepoName
+            ? sourceRepoParts.owner
+            : undefined;
+        const repo = normalizeGithubRepo(implementer.spec.repo, this.#config.repos.org ?? sourceOwner);
+        const baseRef = await this.#githubDefaultBranch(repo);
+        const result = await githubWrite.publishPullRequest({
+            repo,
+            clonePath: implementer.spec.clonePath,
+            baseRef,
+            title: `${issue.key}: ${issue.title}`,
+            body: githubPullRequestBody(issue),
+        });
+        this.#publishedPullRequests.add(key);
+        this.#increment('githubPullRequestsPublished');
+        this.#logger.info?.('[factory] published PR through workspace GitHub connection', {
+            issue: issue.key,
+            repo: result.repo,
+            prNumber: result.number,
+            url: result.url,
+        });
+        return result;
+    }
+    async #githubDefaultBranch(repo) {
+        const parts = githubRepoParts(repo);
+        if (!parts) {
+            throw new Error(`GitHub repo must be owner/repo before resolving its default branch: ${repo}`);
+        }
+        const path = `/github/repos/${encodeURIComponent(parts.owner)}/${encodeURIComponent(parts.repo)}/meta.json`;
+        let payload;
+        try {
+            payload = wrappedPayload((await this.#mount.readFile(path)).content);
+        }
+        catch (error) {
+            throw new Error(`Unable to resolve the default branch for ${repo} from ${path}: ${describeError(error).errorMessage}`);
+        }
+        const repository = asRecord(payload.repository);
+        const defaultBranch = (stringValue(payload.defaultBranch) ??
+            stringValue(payload.default_branch) ??
+            stringValue(repository?.defaultBranch) ??
+            stringValue(repository?.default_branch))?.trim();
+        if (!defaultBranch) {
+            throw new Error(`GitHub repository metadata for ${repo} does not include a default branch`);
+        }
+        return defaultBranch;
+    }
     // An implementer that exited, was resumed once, and STILL produced no PR is
     // not making progress. Surface it (counter + a best-effort Slack note to the
     // dispatch thread) so a human can step in, instead of the issue sitting
@@ -2312,6 +2482,75 @@ export class FactoryLoop {
             this.#logger.warn?.('[factory] failed to post stalled-issue escalation to Slack', error);
         }
     }
+    // An implementer that collided on its leaked broker name, or that exited a
+    // second time with no PR, is terminal: it will never send the completion DM
+    // the reviewer is blocked on (its prompt is literally "Wait for a DM from the
+    // implementer(s)"). Left alone, the reviewer stays live forever and the
+    // owned-broker dispose-wait stalls until FACTORY_AGENT_EXIT_TIMEOUT_MS
+    // (default 30 min), so the issue never reaches human-review (#67). Signal any
+    // waiting reviewer(s) so they can proceed, then resolve the dispatch
+    // deterministically: complete to the terminal state when a PR is now visible
+    // (mount lag at exit time is why we fell through to resume in the first
+    // place), otherwise escalate and tear down the stuck agents so dispose drains.
+    async #concludeTerminalImplementer(record, implementerName, reason) {
+        await this.#signalReviewersImplementerDone(record, implementerName, reason);
+        if (await this.#issueHasCompletionPr(record)) {
+            await this.#completeIssue(record);
+            return;
+        }
+        await this.#escalateStalledIssue(record, implementerName);
+        await this.#abandonStuckDispatch(record, reason);
+    }
+    // Deliver a synthetic "implementer done" DM so a reviewer blocked on the
+    // implementer's message unblocks and proceeds (review the PR if one is open,
+    // otherwise conclude). Best-effort: the deterministic teardown below is the
+    // backstop when the reviewer cannot act on it.
+    async #signalReviewersImplementerDone(record, implementerName, reason) {
+        const reviewers = new Set([...record.agents.values()]
+            .filter((agent) => agent.spec.role === 'reviewer')
+            .map((agent) => agent.result?.name ?? agent.spec.name)
+            .filter((name) => Boolean(name)));
+        for (const reviewer of reviewers) {
+            try {
+                await this.#fleet.sendMessage({
+                    to: reviewer,
+                    from: implementerName,
+                    text: `[factory] implementer ${implementerName} has terminated (${reason}) and will send no further messages. If a pull request is open for this issue, review it now; otherwise conclude your review and DM \`broker\` that you are done.`,
+                });
+                this.#increment('reviewerImplementerTerminatedSignals');
+            }
+            catch (error) {
+                this.#logger.warn?.('[factory] failed to signal reviewer of implementer termination', {
+                    issue: record.issue.key,
+                    reviewer,
+                    error,
+                });
+            }
+        }
+    }
+    // Tear down agents still live after a terminal implementer produced no PR —
+    // chiefly the reviewer, blocked on a DM that will never arrive — and free the
+    // batch slot, so the owned-broker dispose-wait drains instead of stalling for
+    // the full agent-exit timeout. Marking each agent terminal first suppresses
+    // the release-driven exit event so it cannot re-trigger a resume before the
+    // record leaves the batch.
+    async #abandonStuckDispatch(record, reason) {
+        const remaining = [...record.agents].filter(([, tracked]) => tracked.spec.role !== 'implementer');
+        for (const [agentName] of remaining) {
+            this.#fleet.markAgentTerminal?.(agentName, `implementer-terminal:${reason}`);
+        }
+        if (remaining.length > 0) {
+            await this.#releaseAndTerminateAgents(remaining, 'issue-abandoned', 'completion');
+        }
+        await this.#recordDispatchTerminal(record.issue);
+        const next = (await this.#batch()).complete(record.issue);
+        await this.#stopSlackWatcher(record.issue);
+        await this.#stopGithubIssueCommentWatcherForIssue(record.issue);
+        await this.#writeInFlightRegistry();
+        if (next) {
+            await this.dispatch(next.decision, { dryRun: next.dryRun });
+        }
+    }
     async #issueHasCompletionPr(record) {
         try {
             const issue = await this.#readIssue(record.issue.path);
@@ -3410,6 +3649,10 @@ export class FactoryLoop {
             this.#probePrResolvedCache.delete(completionKey);
             this.#babysitterSpawned.delete(record.issue.key);
             this.#babysitterPr.delete(record.issue.key);
+            for (const publishedKey of this.#publishedPullRequests) {
+                if (publishedKey.startsWith(`${record.issue.key}:`))
+                    this.#publishedPullRequests.delete(publishedKey);
+            }
         }
     }
     #emit(event, payload) {
@@ -4261,6 +4504,7 @@ export class FactoryLoop {
             prNumber: probe.prNumber,
             expectedIssueKey: issue.key,
             requireTitleMarker: false,
+            ...(this.#mount.githubWrite ? { githubWrite: this.#mount.githubWrite } : {}),
         });
         this.#increment('mergeGateSyntheticClosed');
     }
@@ -5310,8 +5554,12 @@ const isAllowedFactoryDraft = async (path, content, opts, mount, config) => {
     if (/^\/slack\/channels\/[^/]+\/messages\/.+/u.test(path)) {
         return true;
     }
+    if (isFactoryGithubWritebackPath(path)) {
+        return true;
+    }
     return false;
 };
+const isFactoryGithubWritebackPath = (path) => /^\/github\/repos\/[^/]+\/[^/]+\/(?:pull-requests\/factory-[^/]+\.json|refs\/refs%2Fheads%2F[^/]+\.json|pulls\/[1-9]\d*\/close\.json)$/iu.test(path);
 const isIssuePathInFactoryScope = async (mount, path, config) => {
     try {
         return isInFactoryScope(parseLinearIssue(path, (await mount.readFile(path)).content), config.safety);
@@ -5469,6 +5717,22 @@ const labelName = (value) => {
     return stringValue(record?.name);
 };
 const isCompletionReason = (reason) => reason === 'issue-done' || reason === 'done' || reason === 'completed';
+const normalizeGithubRepo = (repo, defaultOwner) => {
+    if (repo.includes('/'))
+        return repo;
+    const owner = defaultOwner?.trim();
+    if (!owner) {
+        throw new Error(`GitHub repository owner is required for bare repo route: ${repo}; set repos.org or use owner/repo`);
+    }
+    return `${owner}/${repo}`;
+};
+const githubPullRequestBody = (issue) => [
+    issue.description,
+    '',
+    isGithubIssue(issue) && /^\d+$/u.test(issue.key)
+        ? `Fixes #${issue.key}`
+        : `Factory issue ${issue.key}`,
+].join('\n').trim();
 // The broker rejects re-registering a name it never released on exit
 // (relay#1116-family) with a 500 "agent '<name>' already exists". Detect it from
 // the structured payload or the message so resume can treat it as terminal