@agent-relay/factory 0.1.7 → 0.1.9

package/dist/orchestrator/factory.js

@@ -10,7 +10,7 @@ import { isInFactoryScope } from '../safety/factory-scope.js';
 import { deriveDescriptorsFromMount, prescriptiveInstructions, } from '@agent-relay/integration-prompts';
 import { renderAgentTask } from '../dispatch/templates.js';
 import { HeuristicTriage, TieredTriage, babysitterSpec, isShapeLabel, scopeFromLabels } from '../triage/index.js';
-import { MountGithubRead, MountLinearWriteback, MountSlackWriteback } from '../writeback/index.js';
+import { MountGithubRead, MountLinearWriteback, MountSlackWriteback, slackChannelAliases, slackChannelSegment } from '../writeback/index.js';
 import { asRecord, parseJsonContent, stableHash, wrappedPayload } from '../writeback/shared.js';
 import { issueKey } from './batch-tracker.js';
 import { findAgentProcessByName, readProcessIdentity } from './process-identity.js';
@@ -98,6 +98,8 @@ export class FactoryLoop {
     #resumeInFlight = new Map();
     #slackWatchers = new Map();
     #slackWatcherStarts = new Map();
+    #resolvedSlackChannelDir;
+    #slackChannelDirRefresh;
     // Agents we've already logged an ambiguous-PID-lookup warning for, so the
     // reaper doesn't spam the same benign "ambiguous process lookup" line on every
     // poll (a joined/cloud agent has no local PID to resolve — expected).
@@ -1137,7 +1139,7 @@ export class FactoryLoop {
         const escalationReason = triageEscalationReason(decision);
         if (escalationReason) {
             await this.#escalateTriageToSlack(decision, escalationReason, dryRun);
-            this.#error(new Error(`${escalationReason}; escalation required`), decision.issue);
+            this.#recordTriageEscalation(decision, escalationReason);
             return { issue: decision.issue, agents: [], dryRun };
         }
         // TODO(AR-274 follow-up): short-circuit LLM triage once label-derived
@@ -1326,7 +1328,7 @@ export class FactoryLoop {
             const escalationReason = triageEscalationReason(decision);
             if (escalationReason) {
                 await this.#escalateTriageToSlack(decision, escalationReason, this.#config.dryRun);
-                this.#error(new Error(`${escalationReason}; escalation required`), decision.issue);
+                this.#recordTriageEscalation(decision, escalationReason);
                 return;
             }
             if (batch.canStart()) {
@@ -2513,12 +2515,15 @@ export class FactoryLoop {
             });
             if (this.#slack && this.#config.slack && !await this.#shouldSkipSlackWriteback('merge-done-thread')) {
                 try {
-                    const root = await this.#slack.postThread({
-                        channel: this.#config.slack.channel,
-                        text: `${issue.key}: PR merged; Linear state set to Done.`,
-                    });
-                    await this.#slack.reply(root.threadId, `${issue.key}: Linear state set to Done.`);
-                    this.#recordSlackWritebackSuccess('merge-done-thread');
+                    const channel = await this.#slackChannelDir();
+                    if (channel) {
+                        const root = await this.#slack.postThread({
+                            channel,
+                            text: `${issue.key}: PR merged; Linear state set to Done.`,
+                        });
+                        await this.#slack.reply(root.threadId, `${issue.key}: Linear state set to Done.`);
+                        this.#recordSlackWritebackSuccess('merge-done-thread');
+                    }
                 }
                 catch (error) {
                     this.#markSlackWritebackFailure('merge-done-thread', error);
@@ -2752,21 +2757,24 @@ export class FactoryLoop {
             }
             if (this.#slack && this.#config.slack && !await this.#shouldSkipSlackWriteback('completion-thread')) {
                 try {
-                    const merged = opts.completionReason === 'pr-merged';
-                    const completionText = merged
-                        ? `${record.issue.key}: PR merged; Linear state set to ${statusLabel}.`
-                        : `${record.issue.key}: factory agents completed${humanReview ? '; awaiting human review' : ''}.\nStatus: ${statusLabel}\nMerge policy: ${this.#config.mergePolicy}`;
-                    const stateText = merged
-                        ? `${record.issue.key}: PR merged; Linear state set to ${statusLabel}.`
-                        : humanReview
-                            ? `${record.issue.key}: awaiting human review; Linear state set to ${statusLabel}.`
-                            : `${record.issue.key}: Linear state set to ${statusLabel}.`;
-                    const root = await this.#slack.postThread({
-                        channel: this.#config.slack.channel,
-                        text: completionText,
-                    });
-                    await this.#slack.reply(root.threadId, stateText);
-                    this.#recordSlackWritebackSuccess('completion-thread');
+                    const channel = await this.#slackChannelDir();
+                    if (channel) {
+                        const merged = opts.completionReason === 'pr-merged';
+                        const completionText = merged
+                            ? `${record.issue.key}: PR merged; Linear state set to ${statusLabel}.`
+                            : `${record.issue.key}: factory agents completed${humanReview ? '; awaiting human review' : ''}.\nStatus: ${statusLabel}\nMerge policy: ${this.#config.mergePolicy}`;
+                        const stateText = merged
+                            ? `${record.issue.key}: PR merged; Linear state set to ${statusLabel}.`
+                            : humanReview
+                                ? `${record.issue.key}: awaiting human review; Linear state set to ${statusLabel}.`
+                                : `${record.issue.key}: Linear state set to ${statusLabel}.`;
+                        const root = await this.#slack.postThread({
+                            channel,
+                            text: completionText,
+                        });
+                        await this.#slack.reply(root.threadId, stateText);
+                        this.#recordSlackWritebackSuccess('completion-thread');
+                    }
                 }
                 catch (error) {
                     this.#markSlackWritebackFailure('completion-thread', error);
@@ -2813,6 +2821,13 @@ export class FactoryLoop {
     #increment(name) {
         this.#counters[name] = (this.#counters[name] ?? 0) + 1;
     }
+    #recordTriageEscalation(decision, reason) {
+        this.#increment('triageEscalations');
+        this.#logger.warn?.('[factory] triage escalation required', {
+            issue: decision.issue,
+            reason,
+        });
+    }
     async #shouldSkipSlackWriteback(context) {
         if (!this.#config.slack)
             return false;
@@ -3012,7 +3027,7 @@ export class FactoryLoop {
             return;
         }
         const root = await this.#slack.postThread({
-            channel: this.#config.slack.channel,
+            channel: await this.#slackChannelDir() ?? this.#config.slack.channel,
             text: [
                 `${record.issue.key}: factory agents dispatched.`,
                 `State: ${result.stateId ?? 'dispatching'}`,
@@ -3073,11 +3088,11 @@ export class FactoryLoop {
         }
         const issue = await this.#readIssue(decision.issue.path);
         const root = await this.#slack.postThread({
-            channel: this.#config.slack.channel,
+            channel: await this.#slackChannelDir() ?? this.#config.slack.channel,
             text: [
                 `${decision.issue.key}: factory triage escalation for ${issue?.title ?? decision.issue.key}`,
                 `Reason: ${reason}`,
-                `Question: Please clarify the intended repo/approach or add enough acceptance detail for the factory agent to proceed.`,
+                `Question: ${triageEscalationQuestion(decision)}`,
             ].join('\n'),
         });
         await this.#state.setSlackThread(this.#workspaceId, issueKey(decision.issue), root.threadId);
@@ -3092,7 +3107,7 @@ export class FactoryLoop {
         if (this.#slackWatchers.has(key)) {
             return;
         }
-        const channelDir = this.#config.slack.channel;
+        const channelDir = await this.#slackChannelDir() ?? this.#config.slack.channel;
         const messagesPrefix = slackChannelMessagesPrefix(channelDir);
         const preExistingPaths = new Set();
         const seenReplies = new Set();
@@ -3268,17 +3283,24 @@ export class FactoryLoop {
         }
     }
     async #routeSlackAnswerToImplementers(record, reply) {
-        if (!this.#config.slack || !this.#fleet.sendInput) {
+        if (!this.#config.slack) {
+            return;
+        }
+        const text = reply.text.trim();
+        if (!text) {
+            this.#increment('slackAnswersIgnoredEmpty');
             return;
         }
         const liveRecord = (await this.#batch()).getIssue(record.issue);
         if (!liveRecord || liveRecord.dryRun) {
+            if (isTriageEscalationWatchRecord(record)) {
+                await this.#handleTriageEscalationSlackAnswer(record, text);
+                return;
+            }
             this.#increment('slackAnswersIgnoredNoInFlight');
             return;
         }
-        const text = reply.text.trim();
-        if (!text) {
-            this.#increment('slackAnswersIgnoredEmpty');
+        if (!this.#fleet.sendInput) {
             return;
         }
         // Route human replies to the implementers AND the babysitter — once a PR is
@@ -3296,6 +3318,49 @@ export class FactoryLoop {
             this.#increment('slackAnswersInjected');
         }
     }
+    async #handleTriageEscalationSlackAnswer(record, text) {
+        const issue = await this.#readIssue(record.issue.path);
+        if (!issue || !isInFactoryScope(issue, this.#config.safety) || !isRealLinearIssue(issue)) {
+            this.#increment('slackTriageAnswersIgnoredIssueUnavailable');
+            return;
+        }
+        if (!this.#states.isRole(issue.stateId, 'readyForAgent')) {
+            this.#increment('slackTriageAnswersIgnoredIssueNotReady');
+            return;
+        }
+        const batch = await this.#batch();
+        if (batch.isInFlight(record.issue) || batch.isQueued(record.issue)) {
+            this.#increment('slackTriageAnswersIgnoredAlreadyActive');
+            return;
+        }
+        if (await this.#dispatchBlockReason(record.issue)) {
+            this.#increment('slackTriageAnswersIgnoredBlocked');
+            return;
+        }
+        const clarifiedIssue = issueWithSlackClarification(issue, text);
+        const decision = await this.#triage.triage(clarifiedIssue, {
+            config: this.#config,
+            repoMap: repoMapFromConfig(this.#config),
+        });
+        const escalationReason = triageEscalationReason(decision);
+        if (escalationReason) {
+            this.#increment('slackTriageAnswersStillEscalated');
+            this.#logger.warn?.('[factory] Slack triage answer still leaves issue escalated', {
+                issue: record.issue,
+                reason: escalationReason,
+            });
+            return;
+        }
+        if (batch.canStart()) {
+            await this.dispatch(decision, { dryRun: this.#config.dryRun });
+            this.#increment('slackTriageAnswersDispatched');
+            return;
+        }
+        if (batch.queue(decision, this.#config.dryRun)) {
+            this.#increment('slackTriageAnswersQueued');
+            this.#emit('issue-queued', { issue: decision.issue });
+        }
+    }
     // Inject the human's Slack reply into the agent framed as the
     // <integration-event> the spawn prompt tells it to expect (not an ambiguous
     // "Slack reply for ..." keystroke), so the agent recognizes it as the awaited
@@ -3311,13 +3376,78 @@ export class FactoryLoop {
     #integrationsMountRoot() {
         return resolve(process.cwd(), '.integrations');
     }
+    async #slackChannelDir() {
+        if (!this.#config.slack) {
+            return undefined;
+        }
+        if (this.#resolvedSlackChannelDir) {
+            return this.#resolvedSlackChannelDir;
+        }
+        if (this.#slackChannelDirRefresh) {
+            return this.#slackChannelDirRefresh;
+        }
+        this.#slackChannelDirRefresh = this.#resolveSlackChannelDir()
+            .finally(() => {
+            this.#slackChannelDirRefresh = undefined;
+        });
+        return this.#slackChannelDirRefresh;
+    }
+    async #resolveSlackChannelDir() {
+        const configured = this.#config.slack?.channel.trim();
+        if (!configured) {
+            return undefined;
+        }
+        const configuredSegment = slackChannelSegment(configured);
+        const configuredAliases = slackChannelAliases(configured);
+        if (configuredAliases.size === 0) {
+            return undefined;
+        }
+        let paths;
+        try {
+            paths = await this.#mount.listTree('/slack/channels');
+        }
+        catch (error) {
+            this.#logger.warn?.('[factory] unable to resolve Slack channel from mount; using configured channel value', {
+                channel: configured,
+                error,
+            });
+            this.#resolvedSlackChannelDir = configuredSegment;
+            return this.#resolvedSlackChannelDir;
+        }
+        const channelDirs = [...new Set(paths
+                .map((path) => path.match(/^\/slack\/channels\/([^/]+)/u)?.[1])
+                .filter((channelDir) => Boolean(channelDir)))]
+            .sort();
+        const matches = channelDirs.filter((channelDir) => {
+            const aliases = slackChannelAliases(channelDir);
+            return [...aliases].some((alias) => configuredAliases.has(alias));
+        });
+        if (matches.length === 0) {
+            this.#logger.warn?.('[factory] Slack channel was not found in mount; using configured channel value', {
+                channel: configured,
+            });
+            this.#resolvedSlackChannelDir = configuredSegment;
+            return this.#resolvedSlackChannelDir;
+        }
+        const exact = matches.find((channelDir) => slackChannelSegment(channelDir).toLowerCase() === configuredSegment.toLowerCase());
+        this.#resolvedSlackChannelDir = exact ?? matches[0];
+        if (matches.length > 1 && !exact) {
+            this.#logger.warn?.('[factory] Slack channel name matched multiple mount directories; using first match', {
+                channel: configured,
+                selected: this.#resolvedSlackChannelDir,
+                matches,
+            });
+        }
+        return this.#resolvedSlackChannelDir;
+    }
     async #slackDispatchThreadFor(record) {
         if (!this.#config.slack) {
             return undefined;
         }
         const threadId = await this.#state.getSlackThread(this.#workspaceId, issueKey(record.issue));
+        const channel = await this.#slackChannelDir() ?? this.#config.slack.channel;
         return threadId
-            ? { channel: this.#config.slack.channel, threadId, mountRoot: this.#integrationsMountRoot() }
+            ? { channel, threadId, mountRoot: this.#integrationsMountRoot() }
             : undefined;
     }
     async #runCompletionMergeGate(issue) {
@@ -3701,8 +3831,25 @@ function githubMirrorRepoForIssue(issue) {
     return githubRepoFromUrl(sourceUrlLine?.slice(GITHUB_MIRROR_SOURCE_PREFIX.length));
 }
 function githubRepoFromUrl(url) {
-    const match = url?.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+)\/issues\/\d+(?:[/?#].*)?$/iu);
-    return match?.[1] && match[2] ? `${match[1]}/${match[2]}` : undefined;
+    for (const candidate of githubUrlCandidates(url)) {
+        const match = candidate.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+)\/issues\/\d+(?:[/?#].*)?$/iu);
+        if (match?.[1] && match[2]) {
+            return `${match[1]}/${match[2]}`;
+        }
+    }
+    return undefined;
+}
+function githubUrlCandidates(value) {
+    if (!value) {
+        return [];
+    }
+    const candidates = new Set();
+    const trimmed = value.trim();
+    candidates.add(trimmed.replace(/^<|>$/gu, ''));
+    for (const match of trimmed.matchAll(/https:\/\/github\.com\/[^\s<>)\]]+/giu)) {
+        candidates.add(match[0].replace(/[),.;]+$/gu, ''));
+    }
+    return [...candidates];
 }
 function labelRoutesForIssue(issue, config) {
     const labels = uniqueNormalizedLabels(issue.labels).filter((label) => !isShapeLabel(label));
@@ -4558,6 +4705,35 @@ const triageEscalationReason = (decision) => {
     }
     return `${reasons.join(' and ')}${decision.rationale ? `: ${decision.rationale}` : ''}`;
 };
+const triageEscalationQuestion = (decision) => {
+    const routedRepos = decision.routes.map((route) => route.repo).filter(Boolean);
+    if (routedRepos.length === 0) {
+        return [
+            'Which repository or repositories should handle this issue?',
+            'Please include the intended approach and the acceptance criteria/tests the agent should satisfy.',
+        ].join(' ');
+    }
+    if (decision.thin) {
+        return [
+            `Factory matched ${routedRepos.join(', ')}.`,
+            'Please clarify the concrete expected behavior, constraints, and acceptance criteria/tests before dispatch.',
+        ].join(' ');
+    }
+    return [
+        `Factory matched ${routedRepos.join(', ')}, but triage confidence is low.`,
+        'Please confirm the intended repo/approach or correct the route before dispatch.',
+    ].join(' ');
+};
+const isTriageEscalationWatchRecord = (record) => record.agents.size === 0 && record.invocationIds.size === 0 && triageEscalationReason(record.decision) !== undefined;
+const issueWithSlackClarification = (issue, text) => ({
+    ...issue,
+    description: [
+        issue.description,
+        '',
+        'Human clarification from Slack:',
+        text,
+    ].join('\n'),
+});
 const slackAnswerInput = (issue, text) => `Slack reply for ${issue.key}:\n${text}\r`;
 // The human's Slack-thread reply, framed as an <integration-event> the agent is
 // told (at spawn) to expect — a recognizable injected event, not an ambiguous