@agent-relay/factory 0.0.0 → 0.1.2

package/dist/triage/schema.d.ts

@@ -0,0 +1,344 @@
+import { z } from 'zod';
+export declare const AgentSpecSchema: z.ZodObject<{
+    name: z.ZodString;
+    role: z.ZodEnum<["implementer", "reviewer", "babysitter", "workflow"]>;
+    capability: z.ZodEnum<["spawn:codex", "spawn:claude", "workflow:run"]>;
+    model: z.ZodOptional<z.ZodString>;
+    task: z.ZodString;
+    workflow: z.ZodOptional<z.ZodString>;
+    inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    repo: z.ZodString;
+    clonePath: z.ZodOptional<z.ZodString>;
+    channel: z.ZodOptional<z.ZodString>;
+    node: z.ZodOptional<z.ZodString>;
+    sessionRef: z.ZodOptional<z.ZodString>;
+    invocationId: z.ZodOptional<z.ZodString>;
+    restartPolicy: z.ZodOptional<z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    repo: string;
+    name: string;
+    role: "implementer" | "reviewer" | "babysitter" | "workflow";
+    task: string;
+    capability: "spawn:codex" | "spawn:claude" | "workflow:run";
+    channel?: string | undefined;
+    restartPolicy?: unknown;
+    workflow?: string | undefined;
+    model?: string | undefined;
+    inputs?: Record<string, unknown> | undefined;
+    clonePath?: string | undefined;
+    node?: string | undefined;
+    sessionRef?: string | undefined;
+    invocationId?: string | undefined;
+}, {
+    repo: string;
+    name: string;
+    role: "implementer" | "reviewer" | "babysitter" | "workflow";
+    task: string;
+    capability: "spawn:codex" | "spawn:claude" | "workflow:run";
+    channel?: string | undefined;
+    restartPolicy?: unknown;
+    workflow?: string | undefined;
+    model?: string | undefined;
+    inputs?: Record<string, unknown> | undefined;
+    clonePath?: string | undefined;
+    node?: string | undefined;
+    sessionRef?: string | undefined;
+    invocationId?: string | undefined;
+}>;
+export declare const TriageDecisionSchema: z.ZodObject<{
+    issue: z.ZodObject<{
+        uuid: z.ZodString;
+        key: z.ZodString;
+        path: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        uuid: string;
+        key: string;
+    }, {
+        path: string;
+        uuid: string;
+        key: string;
+    }>;
+    routes: z.ZodArray<z.ZodObject<{
+        repo: z.ZodString;
+        clonePath: z.ZodOptional<z.ZodString>;
+        rationale: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        repo: string;
+        rationale: string;
+        clonePath?: string | undefined;
+    }, {
+        repo: string;
+        rationale: string;
+        clonePath?: string | undefined;
+    }>, "many">;
+    scope: z.ZodEnum<["single", "workflow", "team"]>;
+    implementers: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        role: z.ZodEnum<["implementer", "reviewer", "babysitter", "workflow"]>;
+        capability: z.ZodEnum<["spawn:codex", "spawn:claude", "workflow:run"]>;
+        model: z.ZodOptional<z.ZodString>;
+        task: z.ZodString;
+        workflow: z.ZodOptional<z.ZodString>;
+        inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        repo: z.ZodString;
+        clonePath: z.ZodOptional<z.ZodString>;
+        channel: z.ZodOptional<z.ZodString>;
+        node: z.ZodOptional<z.ZodString>;
+        sessionRef: z.ZodOptional<z.ZodString>;
+        invocationId: z.ZodOptional<z.ZodString>;
+        restartPolicy: z.ZodOptional<z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        repo: string;
+        name: string;
+        role: "implementer" | "reviewer" | "babysitter" | "workflow";
+        task: string;
+        capability: "spawn:codex" | "spawn:claude" | "workflow:run";
+        channel?: string | undefined;
+        restartPolicy?: unknown;
+        workflow?: string | undefined;
+        model?: string | undefined;
+        inputs?: Record<string, unknown> | undefined;
+        clonePath?: string | undefined;
+        node?: string | undefined;
+        sessionRef?: string | undefined;
+        invocationId?: string | undefined;
+    }, {
+        repo: string;
+        name: string;
+        role: "implementer" | "reviewer" | "babysitter" | "workflow";
+        task: string;
+        capability: "spawn:codex" | "spawn:claude" | "workflow:run";
+        channel?: string | undefined;
+        restartPolicy?: unknown;
+        workflow?: string | undefined;
+        model?: string | undefined;
+        inputs?: Record<string, unknown> | undefined;
+        clonePath?: string | undefined;
+        node?: string | undefined;
+        sessionRef?: string | undefined;
+        invocationId?: string | undefined;
+    }>, "many">;
+    workflow: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        role: z.ZodEnum<["implementer", "reviewer", "babysitter", "workflow"]>;
+        capability: z.ZodEnum<["spawn:codex", "spawn:claude", "workflow:run"]>;
+        model: z.ZodOptional<z.ZodString>;
+        task: z.ZodString;
+        workflow: z.ZodOptional<z.ZodString>;
+        inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        repo: z.ZodString;
+        clonePath: z.ZodOptional<z.ZodString>;
+        channel: z.ZodOptional<z.ZodString>;
+        node: z.ZodOptional<z.ZodString>;
+        sessionRef: z.ZodOptional<z.ZodString>;
+        invocationId: z.ZodOptional<z.ZodString>;
+        restartPolicy: z.ZodOptional<z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        repo: string;
+        name: string;
+        role: "implementer" | "reviewer" | "babysitter" | "workflow";
+        task: string;
+        capability: "spawn:codex" | "spawn:claude" | "workflow:run";
+        channel?: string | undefined;
+        restartPolicy?: unknown;
+        workflow?: string | undefined;
+        model?: string | undefined;
+        inputs?: Record<string, unknown> | undefined;
+        clonePath?: string | undefined;
+        node?: string | undefined;
+        sessionRef?: string | undefined;
+        invocationId?: string | undefined;
+    }, {
+        repo: string;
+        name: string;
+        role: "implementer" | "reviewer" | "babysitter" | "workflow";
+        task: string;
+        capability: "spawn:codex" | "spawn:claude" | "workflow:run";
+        channel?: string | undefined;
+        restartPolicy?: unknown;
+        workflow?: string | undefined;
+        model?: string | undefined;
+        inputs?: Record<string, unknown> | undefined;
+        clonePath?: string | undefined;
+        node?: string | undefined;
+        sessionRef?: string | undefined;
+        invocationId?: string | undefined;
+    }>>;
+    reviewer: z.ZodObject<{
+        name: z.ZodString;
+        role: z.ZodEnum<["implementer", "reviewer", "babysitter", "workflow"]>;
+        capability: z.ZodEnum<["spawn:codex", "spawn:claude", "workflow:run"]>;
+        model: z.ZodOptional<z.ZodString>;
+        task: z.ZodString;
+        workflow: z.ZodOptional<z.ZodString>;
+        inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        repo: z.ZodString;
+        clonePath: z.ZodOptional<z.ZodString>;
+        channel: z.ZodOptional<z.ZodString>;
+        node: z.ZodOptional<z.ZodString>;
+        sessionRef: z.ZodOptional<z.ZodString>;
+        invocationId: z.ZodOptional<z.ZodString>;
+        restartPolicy: z.ZodOptional<z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        repo: string;
+        name: string;
+        role: "implementer" | "reviewer" | "babysitter" | "workflow";
+        task: string;
+        capability: "spawn:codex" | "spawn:claude" | "workflow:run";
+        channel?: string | undefined;
+        restartPolicy?: unknown;
+        workflow?: string | undefined;
+        model?: string | undefined;
+        inputs?: Record<string, unknown> | undefined;
+        clonePath?: string | undefined;
+        node?: string | undefined;
+        sessionRef?: string | undefined;
+        invocationId?: string | undefined;
+    }, {
+        repo: string;
+        name: string;
+        role: "implementer" | "reviewer" | "babysitter" | "workflow";
+        task: string;
+        capability: "spawn:codex" | "spawn:claude" | "workflow:run";
+        channel?: string | undefined;
+        restartPolicy?: unknown;
+        workflow?: string | undefined;
+        model?: string | undefined;
+        inputs?: Record<string, unknown> | undefined;
+        clonePath?: string | undefined;
+        node?: string | undefined;
+        sessionRef?: string | undefined;
+        invocationId?: string | undefined;
+    }>;
+    thin: z.ZodBoolean;
+    confidence: z.ZodEnum<["high", "low"]>;
+    rationale: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    reviewer: {
+        repo: string;
+        name: string;
+        role: "implementer" | "reviewer" | "babysitter" | "workflow";
+        task: string;
+        capability: "spawn:codex" | "spawn:claude" | "workflow:run";
+        channel?: string | undefined;
+        restartPolicy?: unknown;
+        workflow?: string | undefined;
+        model?: string | undefined;
+        inputs?: Record<string, unknown> | undefined;
+        clonePath?: string | undefined;
+        node?: string | undefined;
+        sessionRef?: string | undefined;
+        invocationId?: string | undefined;
+    };
+    routes: {
+        repo: string;
+        rationale: string;
+        clonePath?: string | undefined;
+    }[];
+    scope: "team" | "workflow" | "single";
+    issue: {
+        path: string;
+        uuid: string;
+        key: string;
+    };
+    rationale: string;
+    implementers: {
+        repo: string;
+        name: string;
+        role: "implementer" | "reviewer" | "babysitter" | "workflow";
+        task: string;
+        capability: "spawn:codex" | "spawn:claude" | "workflow:run";
+        channel?: string | undefined;
+        restartPolicy?: unknown;
+        workflow?: string | undefined;
+        model?: string | undefined;
+        inputs?: Record<string, unknown> | undefined;
+        clonePath?: string | undefined;
+        node?: string | undefined;
+        sessionRef?: string | undefined;
+        invocationId?: string | undefined;
+    }[];
+    thin: boolean;
+    confidence: "high" | "low";
+    workflow?: {
+        repo: string;
+        name: string;
+        role: "implementer" | "reviewer" | "babysitter" | "workflow";
+        task: string;
+        capability: "spawn:codex" | "spawn:claude" | "workflow:run";
+        channel?: string | undefined;
+        restartPolicy?: unknown;
+        workflow?: string | undefined;
+        model?: string | undefined;
+        inputs?: Record<string, unknown> | undefined;
+        clonePath?: string | undefined;
+        node?: string | undefined;
+        sessionRef?: string | undefined;
+        invocationId?: string | undefined;
+    } | undefined;
+}, {
+    reviewer: {
+        repo: string;
+        name: string;
+        role: "implementer" | "reviewer" | "babysitter" | "workflow";
+        task: string;
+        capability: "spawn:codex" | "spawn:claude" | "workflow:run";
+        channel?: string | undefined;
+        restartPolicy?: unknown;
+        workflow?: string | undefined;
+        model?: string | undefined;
+        inputs?: Record<string, unknown> | undefined;
+        clonePath?: string | undefined;
+        node?: string | undefined;
+        sessionRef?: string | undefined;
+        invocationId?: string | undefined;
+    };
+    routes: {
+        repo: string;
+        rationale: string;
+        clonePath?: string | undefined;
+    }[];
+    scope: "team" | "workflow" | "single";
+    issue: {
+        path: string;
+        uuid: string;
+        key: string;
+    };
+    rationale: string;
+    implementers: {
+        repo: string;
+        name: string;
+        role: "implementer" | "reviewer" | "babysitter" | "workflow";
+        task: string;
+        capability: "spawn:codex" | "spawn:claude" | "workflow:run";
+        channel?: string | undefined;
+        restartPolicy?: unknown;
+        workflow?: string | undefined;
+        model?: string | undefined;
+        inputs?: Record<string, unknown> | undefined;
+        clonePath?: string | undefined;
+        node?: string | undefined;
+        sessionRef?: string | undefined;
+        invocationId?: string | undefined;
+    }[];
+    thin: boolean;
+    confidence: "high" | "low";
+    workflow?: {
+        repo: string;
+        name: string;
+        role: "implementer" | "reviewer" | "babysitter" | "workflow";
+        task: string;
+        capability: "spawn:codex" | "spawn:claude" | "workflow:run";
+        channel?: string | undefined;
+        restartPolicy?: unknown;
+        workflow?: string | undefined;
+        model?: string | undefined;
+        inputs?: Record<string, unknown> | undefined;
+        clonePath?: string | undefined;
+        node?: string | undefined;
+        sessionRef?: string | undefined;
+        invocationId?: string | undefined;
+    } | undefined;
+}>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/triage/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/triage/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAe1B,CAAA;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkB/B,CAAA"}

package/dist/triage/schema.js

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+export const AgentSpecSchema = z.object({
+    name: z.string(),
+    role: z.enum(['implementer', 'reviewer', 'babysitter', 'workflow']),
+    capability: z.enum(['spawn:codex', 'spawn:claude', 'workflow:run']),
+    model: z.string().optional(),
+    task: z.string(),
+    workflow: z.string().optional(),
+    inputs: z.record(z.unknown()).optional(),
+    repo: z.string(),
+    clonePath: z.string().optional(),
+    channel: z.string().optional(),
+    node: z.string().optional(),
+    sessionRef: z.string().optional(),
+    invocationId: z.string().optional(),
+    restartPolicy: z.unknown().optional(),
+});
+export const TriageDecisionSchema = z.object({
+    issue: z.object({
+        uuid: z.string(),
+        key: z.string(),
+        path: z.string(),
+    }),
+    routes: z.array(z.object({
+        repo: z.string(),
+        clonePath: z.string().optional(),
+        rationale: z.string(),
+    })),
+    scope: z.enum(['single', 'workflow', 'team']),
+    implementers: z.array(AgentSpecSchema),
+    workflow: AgentSpecSchema.optional(),
+    reviewer: AgentSpecSchema,
+    thin: z.boolean(),
+    confidence: z.enum(['high', 'low']),
+    rationale: z.string(),
+});
+//# sourceMappingURL=schema.js.map

package/dist/triage/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/triage/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC;IACtC,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,aAAa,EAAE,UAAU,EAAE,YAAY,EAAE,UAAU,CAAC,CAAC;IACnE,UAAU,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,aAAa,EAAE,cAAc,EAAE,cAAc,CAAC,CAAC;IACnE,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC5B,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC/B,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,QAAQ,EAAE;IACxC,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAChC,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC9B,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC3B,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACjC,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACnC,aAAa,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;CACtC,CAAC,CAAA;AAEF,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC3C,KAAK,EAAE,CAAC,CAAC,MAAM,CAAC;QACd,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;QAChB,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE;QACf,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;KACjB,CAAC;IACF,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC;QACvB,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;QAChB,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;QAChC,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE;KACtB,CAAC,CAAC;IACH,KAAK,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;IAC7C,YAAY,EAAE,CAAC,CAAC,KAAK,CAAC,eAAe,CAAC;IACtC,QAAQ,EAAE,eAAe,CAAC,QAAQ,EAAE;IACpC,QAAQ,EAAE,eAAe;IACzB,IAAI,EAAE,CAAC,CAAC,OAAO,EAAE;IACjB,UAAU,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IACnC,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE;CACtB,CAAC,CAAA"}

package/dist/triage/tiered.d.ts

@@ -0,0 +1,8 @@
+import type { LinearIssue, TriageContext, TriageDecision, TriageEngine } from '../types.js';
+export declare class TieredTriage implements TriageEngine {
+    #private;
+    constructor(heuristic?: TriageEngine, llm?: TriageEngine);
+    triage(issue: LinearIssue, ctx: TriageContext): Promise<TriageDecision>;
+}
+export declare function mergeDecisions(heuristicDecision: TriageDecision, llmDecision: TriageDecision, issue: LinearIssue, ctx: TriageContext): TriageDecision;
+//# sourceMappingURL=tiered.d.ts.map

package/dist/triage/tiered.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tiered.d.ts","sourceRoot":"","sources":["../../src/triage/tiered.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAGxF,qBAAa,YAAa,YAAW,YAAY;;gBAInC,SAAS,GAAE,YAAoC,EAAE,GAAG,CAAC,EAAE,YAAY;IAKzE,MAAM,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC;CAiB9E;AAED,wBAAgB,cAAc,CAC5B,iBAAiB,EAAE,cAAc,EACjC,WAAW,EAAE,cAAc,EAC3B,KAAK,EAAE,WAAW,EAClB,GAAG,EAAE,aAAa,GACjB,cAAc,CAqBhB"}

package/dist/triage/tiered.js

@@ -0,0 +1,47 @@
+import { buildDecision, HeuristicTriage, normalizeDecision, scopeFromLabels } from './heuristic.js';
+export class TieredTriage {
+    #heuristic;
+    #llm;
+    constructor(heuristic = new HeuristicTriage(), llm) {
+        this.#heuristic = heuristic;
+        this.#llm = llm;
+    }
+    async triage(issue, ctx) {
+        const heuristicDecision = await this.#heuristic.triage(issue, ctx);
+        if (!heuristicDecision.thin && heuristicDecision.confidence !== 'low') {
+            return heuristicDecision;
+        }
+        if (!this.#llm) {
+            return { ...heuristicDecision, confidence: 'low' };
+        }
+        try {
+            const llmDecision = await this.#llm.triage(issue, ctx);
+            return mergeDecisions(heuristicDecision, llmDecision, issue, ctx);
+        }
+        catch {
+            return { ...heuristicDecision, confidence: 'low' };
+        }
+    }
+}
+export function mergeDecisions(heuristicDecision, llmDecision, issue, ctx) {
+    const mergedRoutes = llmDecision.routes.length > 0 ? llmDecision.routes : heuristicDecision.routes;
+    const explicitScope = scopeFromLabels(issue.labels);
+    const mergedScope = explicitScope
+        ?? (mergedRoutes.length >= 2 || llmDecision.scope === 'team' || heuristicDecision.scope === 'team'
+            ? 'team'
+            : llmDecision.scope === 'workflow' || heuristicDecision.scope === 'workflow'
+                ? 'workflow'
+                : 'single');
+    return normalizeDecision(buildDecision({
+        issue,
+        config: ctx.config,
+        routes: mergedRoutes,
+        scope: mergedScope,
+        scopeSource: explicitScope ? 'label' : 'inference',
+        thin: llmDecision.thin && heuristicDecision.thin,
+        confidence: mergedRoutes.length === 0 ? 'low' : llmDecision.confidence,
+        rationale: llmDecision.rationale || heuristicDecision.rationale,
+        scopeSlugs: llmDecision.implementers.map((implementer) => implementer.name.replace(/^ar-\d+-impl-?/, '')).filter(Boolean),
+    }), issue, ctx.config);
+}
+//# sourceMappingURL=tiered.js.map

package/dist/triage/tiered.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tiered.js","sourceRoot":"","sources":["../../src/triage/tiered.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAEhG,MAAM,OAAO,YAAY;IACd,UAAU,CAAc;IACxB,IAAI,CAAe;IAE5B,YAAY,YAA0B,IAAI,eAAe,EAAE,EAAE,GAAkB;QAC7E,IAAI,CAAC,UAAU,GAAG,SAAS,CAAA;QAC3B,IAAI,CAAC,IAAI,GAAG,GAAG,CAAA;IACjB,CAAC;IAED,KAAK,CAAC,MAAM,CAAC,KAAkB,EAAE,GAAkB;QACjD,MAAM,iBAAiB,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,KAAK,EAAE,GAAG,CAAC,CAAA;QAClE,IAAI,CAAC,iBAAiB,CAAC,IAAI,IAAI,iBAAiB,CAAC,UAAU,KAAK,KAAK,EAAE,CAAC;YACtE,OAAO,iBAAiB,CAAA;QAC1B,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;YACf,OAAO,EAAE,GAAG,iBAAiB,EAAE,UAAU,EAAE,KAAK,EAAE,CAAA;QACpD,CAAC;QAED,IAAI,CAAC;YACH,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,GAAG,CAAC,CAAA;YACtD,OAAO,cAAc,CAAC,iBAAiB,EAAE,WAAW,EAAE,KAAK,EAAE,GAAG,CAAC,CAAA;QACnE,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,EAAE,GAAG,iBAAiB,EAAE,UAAU,EAAE,KAAK,EAAE,CAAA;QACpD,CAAC;IACH,CAAC;CACF;AAED,MAAM,UAAU,cAAc,CAC5B,iBAAiC,EACjC,WAA2B,EAC3B,KAAkB,EAClB,GAAkB;IAElB,MAAM,YAAY,GAAG,WAAW,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,iBAAiB,CAAC,MAAM,CAAA;IAClG,MAAM,aAAa,GAAG,eAAe,CAAC,KAAK,CAAC,MAAM,CAAC,CAAA;IACnD,MAAM,WAAW,GAAG,aAAa;WAC5B,CAAC,YAAY,CAAC,MAAM,IAAI,CAAC,IAAI,WAAW,CAAC,KAAK,KAAK,MAAM,IAAI,iBAAiB,CAAC,KAAK,KAAK,MAAM;YAChG,CAAC,CAAC,MAAM;YACR,CAAC,CAAC,WAAW,CAAC,KAAK,KAAK,UAAU,IAAI,iBAAiB,CAAC,KAAK,KAAK,UAAU;gBAC1E,CAAC,CAAC,UAAU;gBACZ,CAAC,CAAC,QAAQ,CAAC,CAAA;IAEjB,OAAO,iBAAiB,CAAC,aAAa,CAAC;QACrC,KAAK;QACL,MAAM,EAAE,GAAG,CAAC,MAAM;QAClB,MAAM,EAAE,YAAY;QACpB,KAAK,EAAE,WAAW;QAClB,WAAW,EAAE,aAAa,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,WAAW;QAClD,IAAI,EAAE,WAAW,CAAC,IAAI,IAAI,iBAAiB,CAAC,IAAI;QAChD,UAAU,EAAE,YAAY,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,WAAW,CAAC,UAAU;QACtE,SAAS,EAAE,WAAW,CAAC,SAAS,IAAI,iBAAiB,CAAC,SAAS;QAC/D,UAAU,EAAE,WAAW,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,gBAAgB,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC;KAC1H,CAAC,EAAE,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;AACxB,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,212 @@
+import type { FactoryConfig } from './config/schema.js';
+import type { FactoryStateResolution } from './linear/state-resolver.js';
+import type { AgentSpec, FleetClient, GithubRead, LinearWriteback, MountClient, SlackWriteback } from './ports/index.js';
+import type { StateStore } from './ports/state.js';
+import type { Clock, Logger } from './ports/system.js';
+import type { CloseProbePrInput, CloseProbePrResult } from './github/probe-closer.js';
+import type { GhRunner, GithubMergeGate } from './github/merge-gate.js';
+import type { AgentProcessFinder, ProcessIdentity } from './orchestrator/process-identity.js';
+export interface FactoryPorts {
+    mount: MountClient;
+    fleet: FleetClient;
+    stateStore?: StateStore;
+    stateResolution?: FactoryStateResolution;
+    triage?: TriageEngine;
+    linear?: LinearWriteback;
+    slack?: SlackWriteback;
+    github?: GithubRead;
+    mergeGate?: GithubMergeGate;
+    probeCloser?: ProbeCloser;
+    probePrResolver?: ProbePrResolver;
+    probePrGhRunner?: GhRunner;
+    logger?: Logger;
+    clock?: Clock;
+    processIdentityReader?: (pid: number) => Promise<ProcessIdentity | undefined>;
+    processFinder?: AgentProcessFinder;
+    kill?: (pid: number, signal?: NodeJS.Signals | 0) => boolean;
+    readChildPids?: (pid: number) => Promise<number[]>;
+    terminationGraceMs?: number;
+}
+export interface Factory {
+    start(opts?: FactoryStartOptions): Promise<void>;
+    stop(): Promise<void>;
+    dispose(): Promise<void>;
+    runOnce(opts?: {
+        dryRun?: boolean;
+    }): Promise<IterationReport>;
+    runLoop(opts?: FactoryLoopRunOptions): Promise<IterationReport[]>;
+    triageIssue(issue: LinearIssue): Promise<TriageDecision>;
+    dispatch(decision: TriageDecision, opts?: {
+        dryRun?: boolean;
+    }): Promise<DispatchResult>;
+    status(): FactoryStatus;
+    on(event: 'issue-queued' | 'dispatched' | 'issue-done' | 'writeback-verified' | 'error', listener: (payload: FactoryEventPayload) => void): () => void;
+}
+export interface FactoryStartOptions {
+    mode?: 'backfill-and-subscribe' | 'live';
+    liveSubscription?: Partial<FactoryLiveSubscriptionOptions>;
+}
+export interface FactoryLiveSubscriptionOptions {
+    transport: 'subscribe-and-poll' | 'subscribe' | 'poll';
+    pollIntervalMs: number;
+    eventLimit: number;
+    replaySkewMarginMs: number;
+}
+export interface FactoryLoopRunOptions {
+    dryRun?: boolean;
+    maxIterations?: number;
+    maxConsecutiveFailures?: number;
+    heartbeatPath?: string;
+    registryPath?: string;
+}
+export type FactoryLoopHeartbeatStatus = 'running' | 'idle' | 'stopping';
+export interface FactoryLoopHeartbeat {
+    pid: number;
+    status: FactoryLoopHeartbeatStatus;
+    iteration: number;
+    maxIterations: number;
+    updatedAt: string;
+    updatedAtMs: number;
+    registryPath?: string;
+}
+export interface FactoryInFlightRegistryAgent {
+    name: string;
+    role?: AgentSpec['role'];
+    issue?: IssueRef;
+    sessionRef?: string;
+    pids: number[];
+    processes?: FactoryInFlightRegistryProcess[];
+}
+export interface FactoryInFlightRegistryProcess {
+    pid: number;
+    agentName: string;
+    cmdline: string;
+    startTime: string;
+}
+export interface FactoryInFlightRegistry {
+    pid: number;
+    heartbeatPath?: string;
+    updatedAt: string;
+    updatedAtMs: number;
+    agents: FactoryInFlightRegistryAgent[];
+}
+export interface FactoryLoopLiveness {
+    ok: boolean;
+    stale: boolean;
+    ageMs?: number;
+    heartbeat?: FactoryLoopHeartbeat;
+    reason?: string;
+}
+export interface LinearIssue {
+    uuid: string;
+    key: string;
+    title: string;
+    description: string;
+    stateId: string;
+    state?: {
+        name: string;
+    };
+    labels: string[];
+    project?: string;
+    team?: string;
+    assignee?: string;
+    path: string;
+    raw: Record<string, unknown>;
+}
+export interface IssueRef {
+    uuid: string;
+    key: string;
+    path: string;
+}
+export interface IterationReport {
+    pulled: IssueRef[];
+    triaged: TriageDecision[];
+    dispatched: DispatchResult[];
+    skipped: Array<{
+        issue: IssueRef;
+        reason: string;
+    }>;
+    dryRun: boolean;
+    slackDegraded?: boolean;
+    error?: {
+        message: string;
+        stack?: string;
+    };
+}
+export interface DispatchResult {
+    issue: IssueRef;
+    agents: Array<{
+        name: string;
+        role: AgentSpec['role'];
+    }>;
+    comments?: string[];
+    stateId?: string;
+    dryRun: boolean;
+}
+export interface FactoryStatus {
+    inFlight: IssueRef[];
+    queued: IssueRef[];
+    counters: Record<string, number>;
+    slackDegraded?: boolean;
+    slackDegradedReason?: string;
+}
+export type FactoryEventPayload = {
+    issue: IssueRef;
+} | {
+    issue: IssueRef;
+    result: DispatchResult;
+} | {
+    issue: IssueRef;
+    path: string;
+} | {
+    error: unknown;
+    errorMessage: string;
+    errorStack?: string;
+    issue?: IssueRef;
+};
+export interface TriageEngine {
+    triage(issue: LinearIssue, ctx: TriageContext): Promise<TriageDecision>;
+}
+export interface TriageContext {
+    config: FactoryConfig;
+    repoMap: RepoMapEntry[];
+}
+export interface RepoMapEntry {
+    repo: string;
+    clonePath?: string;
+    source: 'label' | 'project' | 'keyword' | 'default';
+    key?: string;
+}
+export interface TriageDecision {
+    issue: IssueRef;
+    routes: Array<{
+        repo: string;
+        clonePath?: string;
+        rationale: string;
+    }>;
+    scope: 'single' | 'workflow' | 'team';
+    implementers: AgentSpec[];
+    workflow?: AgentSpec;
+    reviewer: AgentSpec;
+    thin: boolean;
+    confidence: 'high' | 'low';
+    rationale: string;
+}
+export interface PrSummary {
+    repo: string;
+    number: number;
+    title?: string;
+    url?: string;
+    /** Advisory only: mount snapshots can lag live GitHub state. Never use this for merge readiness. */
+    state?: string;
+    headRef?: string;
+    baseRef?: string;
+    author?: string;
+    filesChanged?: string[];
+}
+export type ProbePrRef = Pick<CloseProbePrInput, 'repo' | 'prNumber'> & {
+    draft?: boolean;
+};
+export type ProbePrResolver = (issue: LinearIssue) => Promise<ProbePrRef | undefined>;
+export type ProbeCloser = (input: Pick<CloseProbePrInput, 'repo' | 'prNumber' | 'expectedIssueKey' | 'requireTitleMarker'>) => Promise<CloseProbePrResult>;
+//# sourceMappingURL=types.d.ts.map