diff --git a/.claude/skills/changelog/watermark b/.claude/skills/changelog/watermark
index 58fa6535bb..a6d048b56a 100644
--- a/.claude/skills/changelog/watermark
+++ b/.claude/skills/changelog/watermark
@@ -1 +1 @@
-ab68fc27d10412e9d827d07a62374ccc3cd12f12
+e38fbdcbeffbd04cc43f65608ac040cb17a89f68
diff --git a/.claude/skills/docs/watermark b/.claude/skills/docs/watermark
index d9eb0aee6c..a6d048b56a 100644
--- a/.claude/skills/docs/watermark
+++ b/.claude/skills/docs/watermark
@@ -1 +1 @@
-c54025a21c66136ec515ac392d5c072d0e245385
+e38fbdcbeffbd04cc43f65608ac040cb17a89f68
diff --git a/Cargo.lock b/Cargo.lock
index 0856c86427..8d9658290b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2484,6 +2484,7 @@ dependencies = [
  "bytes",
  "chrono",
  "dashmap",
+ "fabro-automation",
  "fabro-types",
  "fabro-util",
  "futures",
diff --git a/apps/fabro-web/app/components/automation-form.tsx b/apps/fabro-web/app/components/automation-form.tsx
index 4788557ec8..395897f718 100644
--- a/apps/fabro-web/app/components/automation-form.tsx
+++ b/apps/fabro-web/app/components/automation-form.tsx
@@ -7,7 +7,7 @@ import type {
   WorkflowSettings,
 } from "@qltysh/fabro-api-client";
 
-import { findApiTrigger, findScheduleTrigger } from "../lib/automation";
+import { findApiTrigger, findGithubIssueTrigger, findScheduleTrigger } from "../lib/automation";
 import { Panel, Row } from "./settings-panel";
 import { INPUT_CLASS } from "./ui";
 import { sandboxRuntime } from "../lib/run-sandbox-lifecycle";
@@ -22,6 +22,10 @@ export interface AutomationFormValues {
   manualEnabled: boolean;
   scheduleEnabled: boolean;
   cron: string;
+  githubIssueEnabled: boolean;
+  githubIssueTriggerLabel: string;
+  githubIssueIssueLabel: string;
+  githubIssueComment: boolean;
 }
 
 export const EMPTY_AUTOMATION_FORM: AutomationFormValues = {
@@ -34,6 +38,10 @@ export const EMPTY_AUTOMATION_FORM: AutomationFormValues = {
   manualEnabled:   true,
   scheduleEnabled: false,
   cron:            "0 9 * * 1-5",
+  githubIssueEnabled: false,
+  githubIssueTriggerLabel: "fabro",
+  githubIssueIssueLabel: "",
+  githubIssueComment: true,
 };
 
 const CRON_PRESETS: ReadonlyArray<{ label: string; value: string }> = [
@@ -46,6 +54,7 @@ const CRON_PRESETS: ReadonlyArray<{ label: string; value: string }> = [
 export function automationToFormValues(automation: Automation): AutomationFormValues {
   const apiTrigger = findApiTrigger(automation);
   const scheduleTrigger = findScheduleTrigger(automation);
+  const githubIssueTrigger = findGithubIssueTrigger(automation);
   return {
     id:              automation.id,
     name:            automation.name,
@@ -56,6 +65,10 @@ export function automationToFormValues(automation: Automation): AutomationFormVa
     manualEnabled:   apiTrigger?.enabled ?? false,
     scheduleEnabled: scheduleTrigger?.enabled ?? false,
     cron:            scheduleTrigger?.expression ?? "0 9 * * 1-5",
+    githubIssueEnabled: githubIssueTrigger?.enabled ?? false,
+    githubIssueTriggerLabel: githubIssueTrigger?.trigger_label ?? "fabro",
+    githubIssueIssueLabel: githubIssueTrigger?.issue_label ?? "",
+    githubIssueComment: githubIssueTrigger?.comment ?? true,
   };
 }
 
@@ -103,6 +116,17 @@ export function triggersFromFormValues(values: AutomationFormValues): Automation
       expression: values.cron.trim(),
     });
   }
+  if (values.githubIssueEnabled) {
+    const issueLabel = values.githubIssueIssueLabel.trim();
+    triggers.push({
+      id:            "github-issue",
+      type:          "github_issue",
+      enabled:       true,
+      trigger_label: values.githubIssueTriggerLabel.trim(),
+      issue_label:   issueLabel === "" ? null : issueLabel,
+      comment:       values.githubIssueComment,
+    });
+  }
   return triggers;
 }
 
@@ -112,7 +136,8 @@ export function isFormValid(values: AutomationFormValues): boolean {
     values.name.trim() !== "" &&
     values.repository.trim() !== "" &&
     values.ref.trim() !== "" &&
-    values.workflow.trim() !== ""
+    values.workflow.trim() !== "" &&
+    (!values.githubIssueEnabled || values.githubIssueTriggerLabel.trim() !== "")
   );
 }
 
@@ -376,6 +401,48 @@ export function AutomationFormFields({
             </div>
           </Row>
         ) : null}
+        <Row title="GitHub issue label" help="Start runs when a matching label is added to a GitHub issue.">
+          <ToggleSwitch
+            checked={values.githubIssueEnabled}
+            onChange={(githubIssueEnabled) => patch({ githubIssueEnabled })}
+            label="Enable GitHub issue label trigger"
+          />
+        </Row>
+        {values.githubIssueEnabled ? (
+          <>
+            <Row title={<Label required>Trigger label</Label>} help="The label that starts this automation when applied.">
+              <input
+                type="text"
+                name="github_issue_trigger_label"
+                aria-label="GitHub trigger label"
+                value={values.githubIssueTriggerLabel}
+                onChange={(e) => patch({ githubIssueTriggerLabel: e.target.value })}
+                placeholder="fabro"
+                autoComplete="off"
+                className={INPUT_CLASS}
+              />
+            </Row>
+            <Row title={<Label optional>Issue label</Label>} help="Optional extra label to pass into the workflow inputs.">
+              <input
+                type="text"
+                name="github_issue_issue_label"
+                aria-label="GitHub issue label"
+                value={values.githubIssueIssueLabel}
+                onChange={(e) => patch({ githubIssueIssueLabel: e.target.value })}
+                placeholder="Bug"
+                autoComplete="off"
+                className={INPUT_CLASS}
+              />
+            </Row>
+            <Row title="Comment on issue" help="Post a comment when Fabro starts or cannot start the run.">
+              <ToggleSwitch
+                checked={values.githubIssueComment}
+                onChange={(githubIssueComment) => patch({ githubIssueComment })}
+                label="Post GitHub issue comments"
+              />
+            </Row>
+          </>
+        ) : null}
       </Panel>
     </>
   );
diff --git a/apps/fabro-web/app/components/runs-list/run-table-row.tsx b/apps/fabro-web/app/components/runs-list/run-table-row.tsx
index 4fdb82777f..f1d9de6aa0 100644
--- a/apps/fabro-web/app/components/runs-list/run-table-row.tsx
+++ b/apps/fabro-web/app/components/runs-list/run-table-row.tsx
@@ -137,6 +137,17 @@ export function RunTableRow({
               </PullRequestChip>
             </span>
           )}
+          {!run.pullRequestUrl && run.sourceIssueUrl && run.sourceIssueNumber != null && (
+            <a
+              href={run.sourceIssueUrl}
+              target="_blank"
+              rel="noopener noreferrer"
+              title={run.sourceIssueTitle}
+              className="relative z-10 font-mono text-xs text-fg-muted hover:text-fg"
+            >
+              #{run.sourceIssueNumber}
+            </a>
+          )}
         </td>
       )}
       <td className="relative z-10 w-10 whitespace-nowrap px-3 py-2.5 text-right">
diff --git a/apps/fabro-web/app/data/runs.ts b/apps/fabro-web/app/data/runs.ts
index 2b277b6d0f..f2301d4a88 100644
--- a/apps/fabro-web/app/data/runs.ts
+++ b/apps/fabro-web/app/data/runs.ts
@@ -35,6 +35,9 @@ export interface RunItem {
   resources?: string;
   actionDisabled?: boolean;
   comments?: number;
+  sourceIssueNumber?: number;
+  sourceIssueTitle?: string;
+  sourceIssueUrl?: string;
   question?: string;
   pendingApproval?: boolean;
   sandboxId?: string;
@@ -115,6 +118,15 @@ export function mapRunListItem(item: Run): RunItem {
     lastEventAt: item.timestamps.last_event_at ?? undefined,
     additions: item.diff?.additions,
     deletions: item.diff?.deletions,
+    sourceIssueNumber: item.source_context?.type === "github_issue"
+      ? item.source_context.issue_number
+      : undefined,
+    sourceIssueTitle: item.source_context?.type === "github_issue"
+      ? item.source_context.issue_title
+      : undefined,
+    sourceIssueUrl: item.source_context?.type === "github_issue"
+      ? item.source_context.issue_url
+      : undefined,
     size: item.size,
   };
 }
diff --git a/apps/fabro-web/app/lib/automation.ts b/apps/fabro-web/app/lib/automation.ts
index 118ab61c2f..84bfdc1b77 100644
--- a/apps/fabro-web/app/lib/automation.ts
+++ b/apps/fabro-web/app/lib/automation.ts
@@ -15,6 +15,12 @@ export function findScheduleTrigger(
   return automation.triggers.find((t): t is TriggerOfType<"schedule"> => t.type === "schedule");
 }
 
+export function findGithubIssueTrigger(
+  automation: Automation,
+): TriggerOfType<"github_issue"> | undefined {
+  return automation.triggers.find((t): t is TriggerOfType<"github_issue"> => t.type === "github_issue");
+}
+
 export function hasEnabledApiTrigger(automation: Automation): boolean {
   return findApiTrigger(automation)?.enabled === true;
 }
diff --git a/apps/fabro-web/app/routes/automations-new.test.tsx b/apps/fabro-web/app/routes/automations-new.test.tsx
index 47f471abf9..91658e48cd 100644
--- a/apps/fabro-web/app/routes/automations-new.test.tsx
+++ b/apps/fabro-web/app/routes/automations-new.test.tsx
@@ -26,6 +26,22 @@ mock.module("@headlessui/react", () => ({
     createElement("div", props, children),
   DialogTitle: ({ children, ...props }: any) =>
     createElement("h2", props, children),
+  Menu: ({ children, ...props }: any) =>
+    createElement("div", props, children),
+  MenuButton: ({ children, ...props }: any) =>
+    createElement("button", { ...props, type: "button" }, children),
+  MenuItem: ({ children, ...props }: any) =>
+    createElement("div", props, typeof children === "function" ? children({ focus: false }) : children),
+  MenuItems: ({ children, ...props }: any) =>
+    createElement("div", props, children),
+  Listbox: ({ children, ...props }: any) =>
+    createElement("div", props, children),
+  ListboxButton: ({ children, ...props }: any) =>
+    createElement("button", { ...props, type: "button" }, children),
+  ListboxOption: ({ children, ...props }: any) =>
+    createElement("div", props, typeof children === "function" ? children({ selected: false }) : children),
+  ListboxOptions: ({ children, ...props }: any) =>
+    createElement("div", props, children),
   Switch: ({ checked, onChange, children, ...props }: any) =>
     createElement(
       "button",
@@ -57,6 +73,10 @@ mock.module("../lib/queries", () => ({
       isLoading: false,
     };
   },
+  useAllRuns: () => ({ data: null, error: null, isLoading: false }),
+  useAuthConfig: () => ({ data: null, error: null, isLoading: false }),
+  useRunsPage: () => ({ data: null, error: null, isLoading: false }),
+  useSystemInfo: () => ({ data: null, error: null, isLoading: false }),
 }));
 
 mock.module("../lib/api-client", () => ({
@@ -89,9 +109,16 @@ mock.module("../lib/api-client", () => ({
     const response = await call();
     return response.data;
   },
+  apiResponse: async function apiResponse<T>(
+    call: () => Promise<T>,
+  ): Promise<T> {
+    return await call();
+  },
+  requestSignalOptions: () => undefined,
   automationsApi: {
     createAutomation: createAutomationMock,
   },
+  runsApi: {},
 }));
 
 mock.module("swr", () => ({
@@ -223,6 +250,25 @@ function switchChecked(renderer: TestRenderer.ReactTestRenderer, label: string)
   return props["aria-checked"] ?? props.checked;
 }
 
+function changeField(
+  renderer: TestRenderer.ReactTestRenderer,
+  label: string,
+  value: string,
+) {
+  renderer.root.findByProps({ "aria-label": label }).props.onChange({
+    target: { value },
+  });
+}
+
+function clickSwitch(renderer: TestRenderer.ReactTestRenderer, label: string) {
+  const props = renderer.root.findByProps({ "aria-label": label }).props;
+  if (typeof props.onClick === "function") {
+    props.onClick();
+  } else {
+    props.onChange(!switchChecked(renderer, label));
+  }
+}
+
 function textFromNode(
   node: ReturnType<TestRenderer.ReactTestRenderer["toJSON"]>,
 ): string {
@@ -297,4 +343,42 @@ describe("AutomationsNew", () => {
     expect(fieldValue(renderer, "Default branch")).toBe("main");
     expect(fieldValue(renderer, "Workflow slug")).toBe("");
   });
+
+  test("creates automation with GitHub issue trigger", async () => {
+    const { renderer } = await renderAutomationsNew("/automations/new");
+
+    await act(async () => changeField(renderer, "Automation name", "Issue Intake"));
+    await act(async () => changeField(renderer, "Repository", "qltysh/fabro"));
+    await act(async () => changeField(renderer, "Workflow slug", "issue_intake"));
+    await act(async () => clickSwitch(renderer, "Enable GitHub issue label trigger"));
+    await act(async () => changeField(renderer, "GitHub trigger label", "fabro"));
+    await act(async () => changeField(renderer, "GitHub issue label", "Bug"));
+
+    await act(async () => {
+      await renderer.root.findByType("form").props.onSubmit({
+        preventDefault() {},
+      });
+    });
+
+    expect(createAutomationMock).toHaveBeenCalledTimes(1);
+    expect(createAutomationMock.mock.calls[0]?.[0]).toMatchObject({
+      id:      "issue-intake",
+      target:  {
+        repository: "qltysh/fabro",
+        ref:        "main",
+        workflow:   "issue_intake",
+      },
+      triggers: [
+        { id: "manual", type: "api", enabled: true },
+        {
+          id:            "github-issue",
+          type:          "github_issue",
+          enabled:       true,
+          trigger_label: "fabro",
+          issue_label:   "Bug",
+          comment:       true,
+        },
+      ],
+    });
+  });
 });
diff --git a/apps/fabro-web/app/routes/run-detail/header.tsx b/apps/fabro-web/app/routes/run-detail/header.tsx
index efc68f09b5..104aad3130 100644
--- a/apps/fabro-web/app/routes/run-detail/header.tsx
+++ b/apps/fabro-web/app/routes/run-detail/header.tsx
@@ -94,6 +94,9 @@ export function RunDetailHeader({
   const sizeChip = (
     <SizeChip size={summary.size} totalUsdMicros={summary.billing?.total_usd_micros} />
   );
+  const sourceIssue = summary.source_context?.type === "github_issue"
+    ? summary.source_context
+    : null;
 
   return (
     <>
@@ -199,6 +202,18 @@ export function RunDetailHeader({
           </HoverCard>
         )}
 
+        {sourceIssue && (
+          <a
+            href={sourceIssue.issue_url}
+            target="_blank"
+            rel="noopener noreferrer"
+            title={sourceIssue.issue_title}
+            className={SECONDARY_BUTTON_CLASS}
+          >
+            <span className="font-mono">Issue #{sourceIssue.issue_number}</span>
+          </a>
+        )}
+
         {actions.approval.visible && (
           <button
             type="button"
diff --git a/apps/fabro-web/app/routes/runs.test.tsx b/apps/fabro-web/app/routes/runs.test.tsx
index 51483cff24..1672e0fb86 100644
--- a/apps/fabro-web/app/routes/runs.test.tsx
+++ b/apps/fabro-web/app/routes/runs.test.tsx
@@ -11,8 +11,14 @@ import {
   shouldRefreshBoardForEvent,
 } from "./runs";
 import { summarizeBatchLifecycleAction } from "../components/runs-list/batch-lifecycle";
+import { mapRunListItem } from "../data/runs";
 
-function boardRun(id: string, column: BoardColumn, questionText?: string): Run {
+function boardRun(
+  id: string,
+  column: BoardColumn,
+  questionText?: string,
+  overrides: Partial<Run> = {},
+): Run {
   const status =
     column === "blocked"
       ? { kind: "blocked" as const, blocked_reason: "human_input_required" as const }
@@ -49,6 +55,7 @@ function boardRun(id: string, column: BoardColumn, questionText?: string): Run {
     sandbox:          null,
     models:           [],
     source_directory: null,
+    source_context:   null,
     timestamps:       {
       created_at:     "2026-04-19T12:00:00Z",
       started_at:     null,
@@ -63,6 +70,7 @@ function boardRun(id: string, column: BoardColumn, questionText?: string): Run {
     superseded_by:    null,
     retried_from:     null,
     links:            { web: null },
+    ...overrides,
   };
 }
 
@@ -83,6 +91,22 @@ describe("runs route board mapping", () => {
     expect(columns.find((column) => column.id === "blocked")?.items[0]?.question).toBe("Older unresolved question?");
   });
 
+  test("maps GitHub issue source context into run list links", () => {
+    const item = mapRunListItem(boardRun("issue-run", "running", undefined, {
+      source_context: {
+        type:         "github_issue",
+        repository:   "qltysh/fabro",
+        issue_number: 42,
+        issue_title:  "Fix flaky CI",
+        issue_url:    "https://github.com/qltysh/fabro/issues/42",
+      },
+    }));
+
+    expect(item.sourceIssueNumber).toBe(42);
+    expect(item.sourceIssueTitle).toBe("Fix flaky CI");
+    expect(item.sourceIssueUrl).toBe("https://github.com/qltysh/fabro/issues/42");
+  });
+
   test("renders an archived column when includeArchived is true", () => {
     const columns = buildBoardColumns(
       {
diff --git a/docs/public/api-reference/fabro-api.yaml b/docs/public/api-reference/fabro-api.yaml
index 35d7511e5e..e9758a9bb4 100644
--- a/docs/public/api-reference/fabro-api.yaml
+++ b/docs/public/api-reference/fabro-api.yaml
@@ -6177,11 +6177,13 @@ components:
       oneOf:
         - $ref: "#/components/schemas/AutomationApiTrigger"
         - $ref: "#/components/schemas/AutomationScheduleTrigger"
+        - $ref: "#/components/schemas/AutomationGithubIssueTrigger"
       discriminator:
         propertyName: type
         mapping:
           api: "#/components/schemas/AutomationApiTrigger"
           schedule: "#/components/schemas/AutomationScheduleTrigger"
+          github_issue: "#/components/schemas/AutomationGithubIssueTrigger"
 
     AutomationApiTrigger:
       description: Trigger that allows callers to create runs through the automation API.
@@ -6228,6 +6230,39 @@ components:
           description: Five-field cron expression evaluated in UTC.
           example: "0 3 * * *"
 
+    AutomationGithubIssueTrigger:
+      description: GitHub issue label trigger. Fires on issues.labeled and resets on issues.unlabeled for the trigger label.
+      type: object
+      additionalProperties: false
+      required:
+        - id
+        - type
+        - enabled
+        - trigger_label
+      properties:
+        id:
+          type: string
+          pattern: "^[a-z0-9][a-z0-9_-]{0,62}$"
+          example: bug
+        type:
+          type: string
+          enum: [github_issue]
+        enabled:
+          type: boolean
+          example: true
+        trigger_label:
+          type: string
+          minLength: 1
+          example: fabro
+        issue_label:
+          type: ["string", "null"]
+          minLength: 1
+          example: Bug
+        comment:
+          type: boolean
+          default: true
+          example: true
+
     CreateAutomationRequest:
       description: Request body for creating an automation.
       type: object
@@ -10266,6 +10301,10 @@ components:
           oneOf:
             - $ref: "#/components/schemas/AutomationRef"
             - type: "null"
+        source_context:
+          oneOf:
+            - $ref: "#/components/schemas/RunSourceContext"
+            - type: "null"
         source_directory:
           type: ["string", "null"]
         labels:
@@ -10582,6 +10621,10 @@ components:
           oneOf:
             - $ref: "#/components/schemas/AutomationRef"
             - type: "null"
+        source_context:
+          oneOf:
+            - $ref: "#/components/schemas/RunSourceContext"
+            - type: "null"
         repository:
           oneOf:
             - $ref: "#/components/schemas/RepositoryRef"
@@ -10696,6 +10739,44 @@ components:
         trigger_id:
           type: ["string", "null"]
 
+    RunSourceContext:
+      description: External source object that caused or anchors a run.
+      oneOf:
+        - $ref: "#/components/schemas/GithubIssueRunSource"
+      discriminator:
+        propertyName: type
+        mapping:
+          github_issue: "#/components/schemas/GithubIssueRunSource"
+
+    GithubIssueRunSource:
+      type: object
+      additionalProperties: false
+      required:
+        - type
+        - repository
+        - issue_number
+        - issue_title
+        - issue_url
+      properties:
+        type:
+          type: string
+          enum: [github_issue]
+        repository:
+          type: string
+          example: owner/repo
+        issue_number:
+          type: integer
+          format: uint64
+          minimum: 0
+          example: 123
+        issue_title:
+          type: string
+          example: Fix production bug
+        issue_url:
+          type: string
+          format: uri
+          example: https://github.com/owner/repo/issues/123
+
     RunOrigin:
       type: object
       required: [kind]
diff --git a/docs/public/changelog/2026-06-08.mdx b/docs/public/changelog/2026-06-08.mdx
new file mode 100644
index 0000000000..15365564f0
--- /dev/null
+++ b/docs/public/changelog/2026-06-08.mdx
@@ -0,0 +1,34 @@
+---
+title: "GitHub issue intake"
+date: "2026-06-08"
+---
+
+## GitHub issues can start automations
+
+GitHub issues can now be used as the intake queue for Fabro automations. Add a `github_issue` trigger to an automation, then apply the configured label to an issue to create and start a run with the issue title, body, author, URL, repository, default branch, trigger label, and delivery ID available as workflow inputs.
+
+```json
+{
+  "type": "github_issue",
+  "id": "from-github-issue",
+  "enabled": true,
+  "trigger_label": "fabro",
+  "issue_label": "Bug",
+  "comment": true
+}
+```
+
+Fabro links the run back to its source issue and can post a comment when the run starts or cannot start. Duplicate webhook deliveries are ignored, and a labeled issue only starts one run until the trigger label is removed and added again.
+
+## More
+
+<Accordion title="API">
+- Added `github_issue` automation triggers to automation create, replace, retrieve, and list responses
+- Run summaries now include `source_context` for runs created from GitHub issues
+- `POST /api/v1/automations/{id}/runs` now returns the created run summary
+</Accordion>
+
+<Accordion title="Improvements">
+- Added the GitHub issue trigger controls to the New Automation form
+- GitHub issue webhooks are acknowledged promptly while matching automations continue in the background
+</Accordion>
diff --git a/docs/public/docs.json b/docs/public/docs.json
index c60ddb57bf..39f45b384e 100644
--- a/docs/public/docs.json
+++ b/docs/public/docs.json
@@ -92,6 +92,7 @@
             "icon": "puzzle-piece",
             "pages": [
               "integrations/github",
+              "integrations/github-issue-intake",
               "integrations/daytona",
               "integrations/litellm",
               "integrations/slack",
@@ -197,6 +198,19 @@
               "GET /api/v1/runs/{id}/events"
             ]
           },
+          {
+            "group": "Automations",
+            "icon": "bolt",
+            "pages": [
+              "GET /api/v1/automations",
+              "POST /api/v1/automations",
+              "GET /api/v1/automations/{id}",
+              "PUT /api/v1/automations/{id}",
+              "DELETE /api/v1/automations/{id}",
+              "GET /api/v1/automations/{id}/runs",
+              "POST /api/v1/automations/{id}/runs"
+            ]
+          },
           {
             "group": "Human-in-the-Loop",
             "icon": "hand",
@@ -242,6 +256,13 @@
                   "GET /api/v1/models",
                   "POST /api/v1/models/{id}/test"
                 ]
+              },
+              {
+                "group": "Webhooks",
+                "icon": "code",
+                "pages": [
+                  "POST /api/v1/webhooks/github"
+                ]
               }
             ]
           }
@@ -251,6 +272,13 @@
         "tab": "Changelog",
         "icon": "clock-rotate-left",
         "groups": [
+          {
+            "group": "June 2026",
+            "icon": "clock-rotate-left",
+            "pages": [
+              "changelog/2026-06-08"
+            ]
+          },
           {
             "group": "May 2026",
             "icon": "clock-rotate-left",
diff --git a/docs/public/integrations/github-issue-intake.mdx b/docs/public/integrations/github-issue-intake.mdx
new file mode 100644
index 0000000000..ce186396b9
--- /dev/null
+++ b/docs/public/integrations/github-issue-intake.mdx
@@ -0,0 +1,133 @@
+---
+title: "GitHub issue intake"
+description: "Start Fabro automations from GitHub issue labels"
+---
+
+GitHub issue intake turns labeled issues into Fabro runs. Use it when GitHub is where work is filed, triaged, or approved, and you want a developer to start automation by applying a label instead of copying issue context into a run form.
+
+When a matching label is added to an issue, Fabro creates and starts a run for the automation's target workflow. The run is linked back to the issue, receives the issue details as workflow inputs, and can optionally post a status comment on the issue.
+
+## Prerequisites
+
+- Fabro is running with the [GitHub App strategy](/integrations/github#github-app-mode)
+- The GitHub App is installed on the repository that owns the issues
+- `GITHUB_APP_WEBHOOK_SECRET` is configured in the server vault
+- A [webhook delivery strategy](/integrations/github#webhook-delivery-strategies) makes `POST /api/v1/webhooks/github` reachable from GitHub
+- The GitHub App subscribes to the **Issues** webhook event in GitHub's app settings
+
+The GitHub App also needs Issues write permission when you enable issue comments. The installer-created app already requests that permission.
+
+## Create an intake automation
+
+Create an automation whose target points at the repository, branch, and workflow that should handle the issue. Then add a `github_issue` trigger.
+
+```json title="POST /api/v1/automations"
+{
+  "id": "issue-intake",
+  "name": "Issue intake",
+  "description": "Turn labeled GitHub issues into Fabro runs.",
+  "target": {
+    "repository": "acme/widgets",
+    "ref": "main",
+    "workflow": "issue-intake"
+  },
+  "triggers": [
+    {
+      "id": "from-github-issue",
+      "type": "github_issue",
+      "enabled": true,
+      "trigger_label": "fabro",
+      "issue_label": "Bug",
+      "comment": true
+    }
+  ]
+}
+```
+
+You can also create the same trigger from the web app by opening **Automations > New automation**, enabling **GitHub issue label trigger**, and filling in the trigger label.
+
+| Field | Purpose |
+|---|---|
+| `trigger_label` | The label that starts the automation when added to an issue |
+| `issue_label` | Optional extra label filter; the issue must also have this label |
+| `comment` | Whether Fabro comments when it starts or cannot start the run; defaults to `true` |
+
+Fabro starts at most one run per automation, trigger, repository, and issue while the trigger label remains on the issue. Remove and re-add the trigger label to start another run for the same issue.
+
+Pull requests are ignored even though GitHub delivers them through the same Issues webhook family.
+
+## Use Issue Inputs
+
+Issue-triggered runs receive these inputs:
+
+| Input | Value |
+|---|---|
+| `github_issue_url` | Browser URL for the issue |
+| `github_issue_number` | Numeric issue number |
+| `github_issue_title` | Issue title |
+| `github_issue_body` | Issue body, or an empty string when absent |
+| `github_issue_author` | GitHub username of the issue author |
+| `github_repository` | Repository slug in `owner/repo` form |
+| `github_default_branch` | Repository default branch from the webhook payload |
+| `github_trigger_label` | Label that matched the trigger |
+| `github_delivery_id` | GitHub webhook delivery ID |
+
+Reference those values with `{{ inputs.<name> }}` in workflow templates:
+
+```dot title="issue-intake.fabro"
+digraph IssueIntake {
+    graph [goal="Triage GitHub issue #{{ inputs.github_issue_number }}: {{ inputs.github_issue_title }}"]
+
+    start [shape=Mdiamond, label="Start"]
+    exit  [shape=Msquare, label="Exit"]
+
+    triage [
+        label="Triage issue",
+        prompt="Read {{ inputs.github_issue_url }} and propose a minimal implementation plan.\n\nIssue body:\n{{ inputs.github_issue_body }}"
+    ]
+
+    start -> triage -> exit
+}
+```
+
+For local development, give the workflow placeholder values in `[run.inputs]` so you can run it by hand before wiring it to GitHub:
+
+```toml title=".fabro/workflows/issue-intake/workflow.toml"
+_version = 1
+
+[workflow]
+graph = "issue-intake.fabro"
+
+[run.inputs]
+github_issue_url = "https://github.com/acme/widgets/issues/123"
+github_issue_number = 123
+github_issue_title = "Example issue"
+github_issue_body = "Describe the bug or task here."
+github_issue_author = "alice"
+github_repository = "acme/widgets"
+github_default_branch = "main"
+github_trigger_label = "fabro"
+github_delivery_id = "local"
+```
+
+## Developer Workflow
+
+1. Create or update the workflow that should handle issues.
+2. Add placeholder `[run.inputs]` values and run it locally with `fabro run .fabro/workflows/issue-intake/workflow.toml`.
+3. Create an automation with a `github_issue` trigger targeting that workflow.
+4. Apply the trigger label to a GitHub issue.
+5. Open the run from the issue comment or the Fabro runs list and inspect the generated plan, logs, and outputs.
+
+## Troubleshooting
+
+### Labeling an issue does not start a run
+
+Verify that the GitHub App is installed on the repository, the app subscribes to the Issues event, and the webhook delivery reaches `POST /api/v1/webhooks/github`. The automation target repository must exactly match the webhook repository slug.
+
+### Re-labeling does not start another run
+
+Fabro keeps the issue's trigger cycle open while the trigger label remains applied. Remove the trigger label first, then add it again.
+
+### No comment appears on the issue
+
+Check that the trigger has `comment = true` and that the GitHub App installation has Issues write permission. Fabro can still start the run if comment posting fails.
diff --git a/docs/public/integrations/github.mdx b/docs/public/integrations/github.mdx
index ba6039d5b3..42238ba6e5 100644
--- a/docs/public/integrations/github.mdx
+++ b/docs/public/integrations/github.mdx
@@ -32,6 +32,7 @@ The rest of this page describes the `app` strategy, which is required for browse
 | **Checkpoint pushing** | After each workflow stage, Fabro pushes the run branch and metadata branch back to origin from inside the sandbox |
 | **Auto-PR** | When `[run.pull_request] enabled = true` in the [run config](/execution/run-configuration#runpull_request), Fabro opens a PR from the agent's working branch after a successful run |
 | **Auto-merge** | When `[run.pull_request] auto_merge = true`, Fabro enables GitHub's auto-merge on created PRs so they merge automatically once required checks pass |
+| **Issue intake** | [GitHub issue intake](/integrations/github-issue-intake) starts automations when a matching label is added to an issue |
 | **Sandbox GITHUB_TOKEN** | When `[run.integrations.github.permissions]` are declared at any layer (workflow, project, or user settings), Fabro mints a scoped Installation Access Token and injects it as `GITHUB_TOKEN` in the sandbox |
 
 ## Setup
@@ -52,14 +53,16 @@ fabro install
 
 When you choose the GitHub App strategy, the CLI opens GitHub with a pre-filled [App Manifest](https://docs.github.com/en/apps/sharing-github-apps/registering-a-github-app-from-a-manifest) containing:
 
-   | Permission | Level | Purpose |
-   |---|---|---|
-   | Contents | Write | Clone repos, push run branches and checkpoints |
-   | Metadata | Read | Look up repository installation status |
-   | Pull requests | Write | Create and update PRs from workflows |
-   | Checks | Write | Report workflow status on commits |
-   | Issues | Write | Create issues from workflows |
-   | Emails | Read | Read verified email for OAuth login |
+| Permission | Level | Purpose |
+|---|---|---|
+| Contents | Write | Clone repos, push run branches and checkpoints |
+| Metadata | Read | Look up repository installation status |
+| Pull requests | Write | Create and update PRs from workflows |
+| Checks | Write | Report workflow status on commits |
+| Issues | Write | Create issues from workflows |
+| Emails | Read | Read verified email for OAuth login |
+
+The manifest grants Issues permission but does not subscribe to webhook events by default. Enable the **Issues** event in the GitHub App settings before using [GitHub issue intake](/integrations/github-issue-intake).
 
 The installer:
 
diff --git a/docs/superpowers/plans/2026-06-08-github-issue-automation-intake-port.md b/docs/superpowers/plans/2026-06-08-github-issue-automation-intake-port.md
new file mode 100644
index 0000000000..cd70cbd3a6
--- /dev/null
+++ b/docs/superpowers/plans/2026-06-08-github-issue-automation-intake-port.md
@@ -0,0 +1,973 @@
+# GitHub Issue Automation Intake Port Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Port the fork's GitHub issue intake feature to upstream Fabro as automation-based `github_issue` triggers, excluding the legacy `github.toml` implementation and all Azure/fork-specific changes.
+
+**Architecture:** GitHub issue intake is an automation trigger type. The existing signed GitHub webhook route receives `issues` events, matches enabled automation triggers for the target repository and labels, materializes a run with issue inputs and source metadata, starts it, records trigger-cycle state for idempotency, and optionally comments on the issue.
+
+**Tech Stack:** Rust crates (`fabro-automation`, `fabro-types`, `fabro-store`, `fabro-github`, `fabro-server`, `fabro-api`), OpenAPI (`docs/public/api-reference/fabro-api.yaml`), generated TypeScript client (`lib/packages/fabro-api-client`), React web app (`apps/fabro-web`), `cargo nextest`, `bun`.
+
+---
+
+## Scope Boundaries
+
+- Port only automation-based issue intake from `/Users/ipt/repos/agentic-factory`.
+- Do not port legacy `github.toml`, `github_issue_config.rs`, `github_issue_orchestrator.rs`, or `fabro-store/src/slate/github_issue_triggers.rs`.
+- Do not port Azure install/deploy/runtime, ipt branding, sandboxd, hosted sandbox, or generated-client churn caused by fork-only Azure schemas.
+- Create a new branch in `/Users/ipt/repos/fabro-fkukuck` before implementation.
+- Do not commit unless the user explicitly asks; use diffs and verification checkpoints instead.
+
+## File Map
+
+- Modify `lib/crates/fabro-automation/src/model.rs`: add `GithubIssueTrigger`, enum variant, validation, and tests.
+- Modify `lib/crates/fabro-automation/src/lib.rs`: export `GithubIssueTrigger`.
+- Modify `lib/crates/fabro-types/src/run.rs`: add `RunSourceContext` and `GithubIssueRunSource`, plus `RunSpec.source_context`.
+- Modify `lib/crates/fabro-types/src/run_event/run.rs`: add `RunCreatedProps.source_context`.
+- Modify `lib/crates/fabro-types/src/run_summary.rs`: add `Run.source_context`.
+- Modify `lib/crates/fabro-types/src/run_projection.rs`: project source context from run-created events.
+- Modify `lib/crates/fabro-types/src/lib.rs`: export source context types.
+- Modify affected tests under `lib/crates/fabro-types/tests/` to add default `source_context: None` and serde coverage.
+- Create `lib/crates/fabro-store/src/slate/automation_trigger_runs.rs`: persistent trigger-cycle and delivery dedupe state.
+- Modify `lib/crates/fabro-store/src/slate/mod.rs` and `lib/crates/fabro-store/src/lib.rs`: expose trigger run store.
+- Modify `lib/crates/fabro-store/Cargo.toml`: add `percent-encoding` if missing.
+- Modify `lib/crates/fabro-github/src/lib.rs`: add `create_issue_comment` and tests.
+- Create `lib/crates/fabro-server/src/automation_runner.rs`: shared automation materialize/create/start helper.
+- Create `lib/crates/fabro-server/src/github_issue_events.rs`: parse issue webhook payloads and build run inputs.
+- Create `lib/crates/fabro-server/src/github_issue_automation_trigger.rs`: match issue events, fire automations, record trigger runs, and post comments.
+- Modify `lib/crates/fabro-server/src/lib.rs`: expose new server modules.
+- Modify `lib/crates/fabro-server/src/server.rs`: attach `AppState` to webhook route state and dispatch issue events after signature verification.
+- Modify `lib/crates/fabro-server/src/server/handler/automations.rs`: use `automation_runner` for manual/API automation runs.
+- Modify `lib/crates/fabro-server/src/server/automation_scheduler.rs`: use `automation_runner` for scheduled automation runs.
+- Modify `lib/crates/fabro-server/src/automation_materializer.rs`: support input overrides and title override for issue runs.
+- Modify run creation call sites in `lib/crates/fabro-server/src/server/handler/runs.rs` and any compile-reported call sites: accept and persist `source_context`.
+- Modify `docs/public/api-reference/fabro-api.yaml`: add `AutomationGithubIssueTrigger`, `RunSourceContext`, `GithubIssueRunSource`, and `source_context` fields.
+- Modify `lib/crates/fabro-api/build.rs`: replace API schemas with shared Rust types.
+- Modify `lib/crates/fabro-api/src/lib.rs` and tests under `lib/crates/fabro-api/tests/`: expose and prove type identity/round trips.
+- Regenerate `lib/packages/fabro-api-client/src/` from the upstream OpenAPI spec.
+- Modify `apps/fabro-web/app/lib/automation.ts`: add `findGithubIssueTrigger`.
+- Modify `apps/fabro-web/app/components/automation-form.tsx`: add issue trigger form fields.
+- Modify `apps/fabro-web/app/data/runs.ts`, `apps/fabro-web/app/routes/runs.tsx`, and `apps/fabro-web/app/routes/run-detail/header.tsx`: surface GitHub issue source links.
+- Modify web tests under `apps/fabro-web/app/routes/*.test.tsx`: cover create form and issue source links.
+
+## Task 1: Prepare Vanilla Branch And Baseline
+
+**Files:**
+- Read-only check: `/Users/ipt/repos/fabro-fkukuck`
+
+- [ ] **Step 1: Confirm clean state and current branch**
+
+Run:
+
+```bash
+git status --short
+git branch --show-current
+git log --oneline -5
+```
+
+Expected: no unexpected modified tracked files. If untracked files exist, leave them alone and proceed only if they do not overlap this plan.
+
+- [ ] **Step 2: Create the feature branch**
+
+Run:
+
+```bash
+git switch -c github-issue-automation-intake
+```
+
+Expected: branch switches to `github-issue-automation-intake`.
+
+- [ ] **Step 3: Run targeted baseline checks**
+
+Run:
+
+```bash
+cargo nextest run -p fabro-automation -p fabro-types -p fabro-store -p fabro-github -p fabro-server -p fabro-api
+```
+
+Expected: PASS. If baseline fails, capture the failing tests and stop before changing code.
+
+## Task 2: Add Automation Trigger Model
+
+**Files:**
+- Modify: `lib/crates/fabro-automation/src/model.rs`
+- Modify: `lib/crates/fabro-automation/src/lib.rs`
+
+- [ ] **Step 1: Add failing model serde tests**
+
+Add tests in the existing `#[cfg(test)] mod tests` in `lib/crates/fabro-automation/src/model.rs`:
+
+```rust
+#[test]
+fn github_issue_trigger_round_trips() {
+    let trigger = AutomationTrigger::GithubIssue(GithubIssueTrigger {
+        id: AutomationTriggerId::new("github-issue").unwrap(),
+        enabled: true,
+        trigger_label: "fabro".to_string(),
+        issue_label: Some("Bug".to_string()),
+        comment: true,
+    });
+
+    let value = toml::Value::try_from(&trigger).unwrap();
+    let parsed: AutomationTrigger = value.try_into().unwrap();
+
+    assert_eq!(parsed, trigger);
+}
+
+#[test]
+fn github_issue_trigger_defaults_comment_to_true() {
+    let parsed: AutomationTrigger = toml::from_str(
+        r#"
+        type = "github_issue"
+        id = "github-issue"
+        enabled = true
+        trigger_label = "fabro"
+        "#,
+    )
+    .unwrap();
+
+    assert_eq!(
+        parsed,
+        AutomationTrigger::GithubIssue(GithubIssueTrigger {
+            id: AutomationTriggerId::new("github-issue").unwrap(),
+            enabled: true,
+            trigger_label: "fabro".to_string(),
+            issue_label: None,
+            comment: true,
+        })
+    );
+}
+```
+
+- [ ] **Step 2: Run tests and verify failure**
+
+Run:
+
+```bash
+cargo nextest run -p fabro-automation github_issue_trigger
+```
+
+Expected: FAIL because `AutomationTrigger::GithubIssue` and `GithubIssueTrigger` do not exist.
+
+- [ ] **Step 3: Implement trigger model**
+
+In `lib/crates/fabro-automation/src/model.rs`, add:
+
+```rust
+fn default_true() -> bool {
+    true
+}
+```
+
+Add the variant:
+
+```rust
+pub enum AutomationTrigger {
+    Api(ApiTrigger),
+    Schedule(ScheduleTrigger),
+    GithubIssue(GithubIssueTrigger),
+}
+```
+
+Update `Automation::enabled_github_issue_triggers`:
+
+```rust
+pub fn enabled_github_issue_triggers(&self) -> impl Iterator<Item = &GithubIssueTrigger> {
+    self.triggers.iter().filter_map(move |trigger| match trigger {
+        AutomationTrigger::GithubIssue(trigger) if trigger.enabled => Some(trigger),
+        _ => None,
+    })
+}
+```
+
+Update `AutomationTrigger::id` and `AutomationTrigger::enabled` match arms to include `Self::GithubIssue(trigger)`.
+
+Add the struct after `ScheduleTrigger`:
+
+```rust
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct GithubIssueTrigger {
+    pub id:            AutomationTriggerId,
+    pub enabled:       bool,
+    pub trigger_label: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub issue_label:   Option<String>,
+    #[serde(default = "default_true")]
+    pub comment:       bool,
+}
+```
+
+In validation, keep existing duplicate-trigger-id and multiple-API-trigger behavior. Do not add special restrictions for GitHub issue triggers beyond existing trigger ID validation.
+
+In `lib/crates/fabro-automation/src/lib.rs`, export `GithubIssueTrigger` with the other model exports.
+
+- [ ] **Step 4: Run tests and verify pass**
+
+Run:
+
+```bash
+cargo nextest run -p fabro-automation
+```
+
+Expected: PASS.
+
+## Task 3: Add Run Source Context Types
+
+**Files:**
+- Modify: `lib/crates/fabro-types/src/run.rs`
+- Modify: `lib/crates/fabro-types/src/run_event/run.rs`
+- Modify: `lib/crates/fabro-types/src/run_summary.rs`
+- Modify: `lib/crates/fabro-types/src/run_projection.rs`
+- Modify: `lib/crates/fabro-types/src/lib.rs`
+- Modify: `lib/crates/fabro-types/tests/run_spec_serde.rs`
+- Modify: `lib/crates/fabro-types/tests/run_spec_methods.rs`
+- Modify: `lib/crates/fabro-types/tests/run_event_serde.rs`
+
+- [ ] **Step 1: Add failing serde tests**
+
+Add a test to `lib/crates/fabro-types/tests/run_spec_serde.rs` using an existing minimal `RunSpec` fixture and assert this JSON fragment round-trips:
+
+```json
+"source_context": {
+  "type": "github_issue",
+  "repository": "owner/repo",
+  "issue_number": 42,
+  "issue_title": "Fix bug",
+  "issue_url": "https://github.com/owner/repo/issues/42"
+}
+```
+
+Add a test to `lib/crates/fabro-types/tests/run_event_serde.rs` asserting `RunCreatedProps` accepts the same `source_context` object.
+
+- [ ] **Step 2: Run tests and verify failure**
+
+Run:
+
+```bash
+cargo nextest run -p fabro-types source_context
+```
+
+Expected: FAIL because source context types and fields do not exist.
+
+- [ ] **Step 3: Implement types and projection fields**
+
+In `lib/crates/fabro-types/src/run.rs`, add before `DirtyStatus`:
+
+```rust
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum RunSourceContext {
+    GithubIssue(GithubIssueRunSource),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct GithubIssueRunSource {
+    pub repository:   String,
+    pub issue_number: u64,
+    pub issue_title:  String,
+    pub issue_url:    String,
+}
+```
+
+Add this field to `RunSpec` after `automation`:
+
+```rust
+#[serde(default, skip_serializing_if = "Option::is_none")]
+pub source_context: Option<RunSourceContext>,
+```
+
+In `lib/crates/fabro-types/src/run_event/run.rs`, import `RunSourceContext` and add this field to `RunCreatedProps` after `automation`:
+
+```rust
+#[serde(default, skip_serializing_if = "Option::is_none")]
+pub source_context: Option<RunSourceContext>,
+```
+
+In `lib/crates/fabro-types/src/run_summary.rs`, add `source_context: Option<RunSourceContext>` after `automation` and import the type.
+
+In `lib/crates/fabro-types/src/run_projection.rs`, initialize `source_context: None` in default summaries and set `summary.source_context = props.source_context.clone()` when projecting `RunCreated`.
+
+In `lib/crates/fabro-types/src/lib.rs`, export `GithubIssueRunSource` and `RunSourceContext`.
+
+- [ ] **Step 4: Update all compile-reported literals**
+
+For every `RunSpec`, `RunCreatedProps`, or `Run` literal reported by the compiler, add:
+
+```rust
+source_context: None,
+```
+
+Place it next to the `automation` field where possible.
+
+- [ ] **Step 5: Run tests and verify pass**
+
+Run:
+
+```bash
+cargo nextest run -p fabro-types
+```
+
+Expected: PASS.
+
+## Task 4: Add Trigger Run Persistence
+
+**Files:**
+- Create: `lib/crates/fabro-store/src/slate/automation_trigger_runs.rs`
+- Modify: `lib/crates/fabro-store/src/slate/mod.rs`
+- Modify: `lib/crates/fabro-store/src/lib.rs`
+- Modify: `lib/crates/fabro-store/Cargo.toml`
+
+- [ ] **Step 1: Add failing store tests**
+
+In the new file, include tests copied and adapted from the fork's `automation_trigger_runs.rs` that verify:
+
+```rust
+decide_github_issue_start starts first delivery;
+decide_github_issue_start returns DuplicateDelivery for the same delivery;
+decide_github_issue_start returns AlreadyOpen while the issue cycle marker is open;
+close_github_issue_cycle allows a later delivery to start a new cycle;
+record_started stores the run_id on the open marker;
+```
+
+Use the fork file as the source of exact test bodies and keep imports adjusted to upstream paths.
+
+- [ ] **Step 2: Run tests and verify failure**
+
+Run:
+
+```bash
+cargo nextest run -p fabro-store automation_trigger_runs
+```
+
+Expected: FAIL until the module is exported and dependencies are wired.
+
+- [ ] **Step 3: Implement persistence module**
+
+Copy the fork implementation from `/Users/ipt/repos/agentic-factory/lib/crates/fabro-store/src/slate/automation_trigger_runs.rs` into upstream with these public types:
+
+```rust
+pub struct AutomationTriggerRunRecord { ... }
+pub enum AutomationTriggerKind { GithubIssue }
+pub enum AutomationEventSource { Github }
+pub enum AutomationTriggerRunStatus { Started, FailedToStart }
+pub enum AutomationTriggerRunContext { GithubIssue { repository: String, issue_number: u64, trigger_label: String, issue_label: Option<String> } }
+pub struct GithubIssueTriggerCycleKey { ... }
+pub struct AutomationTriggerRunStore { pub(super) db: super::Database }
+```
+
+Include the methods:
+
+```rust
+decide_github_issue_start;
+record_started;
+record_failed_to_start;
+close_github_issue_cycle;
+records;
+```
+
+In `lib/crates/fabro-store/src/slate/mod.rs`, add:
+
+```rust
+mod automation_trigger_runs;
+
+pub use automation_trigger_runs::{
+    AutomationEventSource, AutomationTriggerKind, AutomationTriggerRunContext,
+    AutomationTriggerRunRecord, AutomationTriggerRunStatus, AutomationTriggerRunStore,
+    GithubIssueTriggerCycleKey,
+};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum TriggerStartDecision {
+    Start { trigger_cycle: u64 },
+    AlreadyOpen { run_id: Option<RunId> },
+    DuplicateDelivery,
+}
+```
+
+Add an `automation_trigger_runs` `OnceCell` field to `Database`, initialize it in `Database::new`, and add:
+
+```rust
+pub async fn automation_trigger_runs(&self) -> Result<Arc<AutomationTriggerRunStore>> {
+    self.automation_trigger_runs
+        .get_or_init(|| async {
+            Arc::new(AutomationTriggerRunStore { db: self.clone() })
+        })
+        .await
+        .clone()
+        .into()
+}
+```
+
+In `lib/crates/fabro-store/src/lib.rs`, re-export the same public types plus `TriggerStartDecision`.
+
+In `lib/crates/fabro-store/Cargo.toml`, add:
+
+```toml
+percent-encoding = { workspace = true }
+```
+
+- [ ] **Step 4: Run tests and verify pass**
+
+Run:
+
+```bash
+cargo nextest run -p fabro-store automation_trigger_runs
+cargo nextest run -p fabro-store
+```
+
+Expected: PASS.
+
+## Task 5: Add GitHub Issue Comment Helper
+
+**Files:**
+- Modify: `lib/crates/fabro-github/src/lib.rs`
+
+- [ ] **Step 1: Add failing helper test**
+
+Port the fork test `create_issue_comment_posts_body` from `/Users/ipt/repos/agentic-factory/lib/crates/fabro-github/src/lib.rs` into upstream.
+
+- [ ] **Step 2: Run test and verify failure**
+
+Run:
+
+```bash
+cargo nextest run -p fabro-github create_issue_comment_posts_body
+```
+
+Expected: FAIL because `create_issue_comment` does not exist.
+
+- [ ] **Step 3: Implement helper**
+
+Add after repository file-fetch helpers:
+
+```rust
+/// Create a GitHub issue comment with an installation or PAT bearer token.
+pub async fn create_issue_comment(
+    client: &impl HttpClient,
+    token: &str,
+    owner: &str,
+    repo: &str,
+    issue_number: u64,
+    body: &str,
+    base_url: &str,
+) -> anyhow::Result<()> {
+    let url = format!("{base_url}/repos/{owner}/{repo}/issues/{issue_number}/comments");
+    let auth = format!("Bearer {token}");
+    let body = serde_json::json!({ "body": body });
+    let resp = client
+        .request(HttpMethod::Post, &url, &github_headers(&auth), Some(&body))
+        .await
+        .with_context(|| {
+            format!("failed to create issue comment on {owner}/{repo}#{issue_number}")
+        })?;
+
+    match resp.status {
+        200 | 201 => Ok(()),
+        status => bail!(
+            "Unexpected status {status} creating issue comment on {owner}/{repo}#{issue_number}: {}",
+            resp.text()
+        ),
+    }
+}
+```
+
+- [ ] **Step 4: Run tests and verify pass**
+
+Run:
+
+```bash
+cargo nextest run -p fabro-github create_issue_comment_posts_body
+cargo nextest run -p fabro-github
+```
+
+Expected: PASS.
+
+## Task 6: Centralize Automation Run Firing
+
+**Files:**
+- Create: `lib/crates/fabro-server/src/automation_runner.rs`
+- Modify: `lib/crates/fabro-server/src/lib.rs`
+- Modify: `lib/crates/fabro-server/src/server/handler/automations.rs`
+- Modify: `lib/crates/fabro-server/src/server/automation_scheduler.rs`
+- Modify: `lib/crates/fabro-server/src/automation_materializer.rs`
+
+- [ ] **Step 1: Add failing automation runner test**
+
+Port the fork test `fire_automation_run_creates_started_run_with_automation_ref` into the new `automation_runner.rs`. Include `source_context` in the test so this helper proves issue source metadata flows to created run summaries.
+
+- [ ] **Step 2: Run test and verify failure**
+
+Run:
+
+```bash
+cargo nextest run -p fabro-server fire_automation_run_creates_started_run_with_automation_ref
+```
+
+Expected: FAIL because `automation_runner` does not exist.
+
+- [ ] **Step 3: Implement `automation_runner`**
+
+Copy the fork's `lib/crates/fabro-server/src/automation_runner.rs` and adapt imports to upstream. `FireAutomationRunInput` must contain:
+
+```rust
+pub(crate) automation: Automation,
+pub(crate) trigger_id: AutomationTriggerId,
+pub(crate) actor: Principal,
+pub(crate) headers: HeaderMap,
+pub(crate) input_overrides: HashMap<String, toml::Value>,
+pub(crate) title_override: Option<String>,
+pub(crate) source_context: Option<RunSourceContext>,
+```
+
+`fire_automation_run` must materialize, create via upstream `create_run_from_manifest`, and call `queue_run_start`.
+
+- [ ] **Step 4: Add input and title overrides to materializer**
+
+In `AutomationRunMaterializeInput`, add:
+
+```rust
+pub input_overrides: HashMap<String, toml::Value>,
+pub title_override: Option<String>,
+```
+
+In `build_manifest_from_checkout`, construct `ManifestBuildInput` with:
+
+```rust
+input_overrides: input.input_overrides.clone(),
+```
+
+After manifest build, apply title override:
+
+```rust
+if let Some(title) = input.title_override.clone() {
+    manifest.title = Some(title.try_into().map_err(|err| {
+        AutomationRunMaterializeError::Manifest(format!("invalid automation run title: {err}"))
+    })?);
+}
+```
+
+When overrides are present, set submitted manifest args:
+
+```rust
+if !submitted_input_overrides.is_empty() {
+    manifest.args = Some(ManifestArgs {
+        input: input_overrides_as_args(&submitted_input_overrides),
+        ..ManifestArgs::default()
+    });
+}
+```
+
+Add helper functions `input_overrides_as_args` and `input_override_arg_value` from the fork.
+
+- [ ] **Step 5: Replace manual and scheduled automation firing**
+
+In `handler/automations.rs`, replace inline materialize/create/start code with `fire_automation_run` and pass empty overrides, no title override, and no source context.
+
+In `automation_scheduler.rs`, replace inline scheduled materialize/create/start code with `fire_automation_run` and pass empty overrides, no title override, and no source context.
+
+- [ ] **Step 6: Update compile-reported materializer inputs**
+
+For every `AutomationRunMaterializeInput` literal, add:
+
+```rust
+input_overrides: HashMap::new(),
+title_override: None,
+```
+
+- [ ] **Step 7: Run tests and verify pass**
+
+Run:
+
+```bash
+cargo nextest run -p fabro-server fire_automation_run_creates_started_run_with_automation_ref
+cargo nextest run -p fabro-server automation
+```
+
+Expected: PASS.
+
+## Task 7: Add GitHub Issue Webhook Automation Handling
+
+**Files:**
+- Create: `lib/crates/fabro-server/src/github_issue_events.rs`
+- Create: `lib/crates/fabro-server/src/github_issue_automation_trigger.rs`
+- Modify: `lib/crates/fabro-server/src/lib.rs`
+- Modify: `lib/crates/fabro-server/src/server.rs`
+- Modify: `lib/crates/fabro-server/src/server/tests.rs`
+- Modify: `lib/crates/fabro-server/src/test_support.rs` if test injection needs existing fork helpers
+
+- [ ] **Step 1: Add event parser tests**
+
+Port the fork tests `parses_issue_labeled_payload` and `builds_v1_workflow_inputs` into `github_issue_events.rs`.
+
+- [ ] **Step 2: Run parser tests and verify failure**
+
+Run:
+
+```bash
+cargo nextest run -p fabro-server github_issue_events
+```
+
+Expected: FAIL because the module does not exist.
+
+- [ ] **Step 3: Implement event parser**
+
+Copy the fork file `lib/crates/fabro-server/src/github_issue_events.rs` unchanged except for import formatting required by upstream.
+
+- [ ] **Step 4: Add webhook integration tests**
+
+Port the fork server tests covering:
+
+```rust
+github_issue_labeled_webhook_starts_matching_automation;
+github_issue_labeled_webhook_ignores_pull_requests;
+github_issue_labeled_webhook_dedupes_open_issue_cycle;
+github_issue_unlabeled_webhook_closes_issue_cycle;
+github_issue_start_failure_posts_failure_comment;
+```
+
+If exact test names differ in the fork, keep upstream names descriptive and assert these outcomes:
+
+```rust
+created run has automation id and trigger id;
+created run title equals issue title;
+created run source_context is GithubIssue;
+materializer input_overrides include github_issue_title and github_issue_url;
+duplicate labeled delivery does not create a second run;
+unlabeled event allows a later labeled event to create a new run;
+comment request body is sent when comment is true;
+```
+
+- [ ] **Step 5: Run webhook tests and verify failure**
+
+Run:
+
+```bash
+cargo nextest run -p fabro-server github_issue
+```
+
+Expected: FAIL because webhook dispatch and trigger handling are not implemented.
+
+- [ ] **Step 6: Implement issue automation trigger handler**
+
+Copy the fork file `lib/crates/fabro-server/src/github_issue_automation_trigger.rs`, adapting only imports and upstream names. Preserve behavior:
+
+```rust
+issues:labeled starts matching automations;
+issues:unlabeled closes open cycles;
+pull requests are ignored;
+matching requires automation.target.repository == event.repository.full_name;
+matching requires changed label == trigger.trigger_label;
+optional trigger.issue_label must be present on the issue;
+source_context is RunSourceContext::GithubIssue;
+title_override is issue title;
+input_overrides are built from GithubIssueRunInputs;
+comments use issues:write token and fabro_github::create_issue_comment;
+```
+
+- [ ] **Step 7: Wire webhook route state**
+
+In `server.rs`, change webhook route state from only `Arc<[u8]>` to:
+
+```rust
+#[derive(Clone)]
+struct GithubWebhookRouteState {
+    secret: Arc<[u8]>,
+    app_state: Arc<AppState>,
+}
+```
+
+Change `github_webhook_routes` to accept `app_state: Arc<AppState>` and `secret: Arc<[u8]>`, and call it from router construction with the existing app state. After successful signature verification and logging, call:
+
+```rust
+crate::github_issue_automation_trigger::handle_github_issue_webhook(
+    Arc::clone(&route_state.app_state),
+    headers,
+    delivery_id,
+    &body,
+)
+.await;
+```
+
+Return `StatusCode::OK` regardless of whether issue automation handling starts a run; webhook delivery was accepted after HMAC verification.
+
+- [ ] **Step 8: Run server tests and verify pass**
+
+Run:
+
+```bash
+cargo nextest run -p fabro-server github_webhook
+cargo nextest run -p fabro-server github_issue
+cargo nextest run -p fabro-server automation
+```
+
+Expected: PASS.
+
+## Task 8: Expose API Schemas And Regenerate Clients
+
+**Files:**
+- Modify: `docs/public/api-reference/fabro-api.yaml`
+- Modify: `lib/crates/fabro-api/build.rs`
+- Modify: `lib/crates/fabro-api/src/lib.rs`
+- Modify: `lib/crates/fabro-api/tests/automation_round_trip.rs`
+- Modify: `lib/crates/fabro-api/tests/run_projection_round_trip.rs`
+- Modify: `lib/crates/fabro-api/tests/run_summary_round_trip.rs`
+- Regenerate: `lib/packages/fabro-api-client/src/**`
+
+- [ ] **Step 1: Add failing API tests**
+
+In `automation_round_trip.rs`, add a GitHub issue trigger to the existing automation fixture:
+
+```rust
+AutomationTrigger::GithubIssue(fabro_automation::GithubIssueTrigger {
+    id: AutomationTriggerId::new("github-issue").unwrap(),
+    enabled: true,
+    trigger_label: "fabro".to_string(),
+    issue_label: Some("Bug".to_string()),
+    comment: true,
+})
+```
+
+In run projection and summary round-trip tests, include a `RunSourceContext::GithubIssue` fixture and assert JSON parity.
+
+- [ ] **Step 2: Run API tests and verify failure**
+
+Run:
+
+```bash
+cargo nextest run -p fabro-api automation_round_trip run_projection_round_trip run_summary_round_trip
+```
+
+Expected: FAIL because OpenAPI lacks the schemas and replacements.
+
+- [ ] **Step 3: Edit OpenAPI**
+
+Add `AutomationGithubIssueTrigger` schema, add it to the `AutomationTrigger` discriminator mapping, add `RunSourceContext` and `GithubIssueRunSource`, and add optional `source_context` to `Run` and `RunSpec`. Use the fork's `docs/public/api-reference/fabro-api.yaml` as the reference, copying only these schemas and fields.
+
+- [ ] **Step 4: Add Rust API replacements**
+
+In `lib/crates/fabro-api/build.rs`, add replacements:
+
+```rust
+(
+    "AutomationGithubIssueTrigger",
+    "fabro_automation::GithubIssueTrigger",
+    &[],
+),
+("RunSourceContext", "fabro_types::RunSourceContext", &[]),
+```
+
+In `lib/crates/fabro-api/src/lib.rs`, expose generated/shared types as needed for tests.
+
+- [ ] **Step 5: Build API and run tests**
+
+Run:
+
+```bash
+cargo build -p fabro-api
+cargo nextest run -p fabro-api
+```
+
+Expected: PASS.
+
+- [ ] **Step 6: Regenerate TypeScript client**
+
+Run:
+
+```bash
+bun run generate
+```
+
+Working directory: `lib/packages/fabro-api-client`.
+
+Expected: generated files include `automation-github-issue-trigger.ts`, `github-issue-run-source.ts`, `run-source-context.ts`, updated `automation-trigger.ts`, `run.ts`, and `run-spec.ts`. Generated diffs must not introduce Azure-only schemas from the fork.
+
+## Task 9: Add Web UI Support
+
+**Files:**
+- Modify: `apps/fabro-web/app/lib/automation.ts`
+- Modify: `apps/fabro-web/app/components/automation-form.tsx`
+- Modify: `apps/fabro-web/app/routes/automations-new.test.tsx`
+- Modify: `apps/fabro-web/app/data/runs.ts`
+- Modify: `apps/fabro-web/app/routes/runs.tsx`
+- Modify: `apps/fabro-web/app/routes/run-detail/header.tsx`
+- Modify: `apps/fabro-web/app/routes/runs.test.tsx`
+
+- [ ] **Step 1: Add failing form test**
+
+Port the fork test `creates automation with GitHub issue trigger` into `automations-new.test.tsx`. Assert the submitted trigger is:
+
+```ts
+{
+  id: "github-issue",
+  type: "github_issue",
+  enabled: true,
+  trigger_label: "fabro",
+  issue_label: "Bug",
+  comment: true,
+}
+```
+
+- [ ] **Step 2: Run test and verify failure**
+
+Run:
+
+```bash
+bun test app/routes/automations-new.test.tsx
+```
+
+Working directory: `apps/fabro-web`.
+
+Expected: FAIL because the form lacks issue trigger fields.
+
+- [ ] **Step 3: Implement automation form fields**
+
+In `automation.ts`, add:
+
+```ts
+export function findGithubIssueTrigger(
+  automation: Automation,
+): TriggerOfType<"github_issue"> | undefined {
+  return automation.triggers.find(
+    (t): t is TriggerOfType<"github_issue"> => t.type === "github_issue",
+  );
+}
+```
+
+In `automation-form.tsx`, add form values:
+
+```ts
+githubIssueEnabled: boolean;
+githubIssueTriggerLabel: string;
+githubIssueIssueLabel: string;
+githubIssueComment: boolean;
+```
+
+Use defaults:
+
+```ts
+githubIssueEnabled: false,
+githubIssueTriggerLabel: "fabro",
+githubIssueIssueLabel: "",
+githubIssueComment: true,
+```
+
+Add trigger serialization:
+
+```ts
+if (values.githubIssueEnabled) {
+  const issueLabel = values.githubIssueIssueLabel.trim();
+  triggers.push({
+    id:            "github-issue",
+    type:          "github_issue",
+    enabled:       true,
+    trigger_label: values.githubIssueTriggerLabel.trim(),
+    issue_label:   issueLabel === "" ? null : issueLabel,
+    comment:       values.githubIssueComment,
+  });
+}
+```
+
+Add validation:
+
+```ts
+(!values.githubIssueEnabled || values.githubIssueTriggerLabel.trim() !== "")
+```
+
+Add UI rows under Triggers for GitHub issues, trigger label, optional issue label, and comment switch, matching the fork implementation.
+
+- [ ] **Step 4: Add failing source link tests**
+
+Port fork `runs.test.tsx` assertions that GitHub issue source context renders a link to the issue in run lists and run detail headers.
+
+- [ ] **Step 5: Implement source issue links**
+
+Port fork changes in:
+
+```text
+apps/fabro-web/app/data/runs.ts
+apps/fabro-web/app/routes/runs.tsx
+apps/fabro-web/app/routes/run-detail/header.tsx
+```
+
+The UI should link to `run.source_context.issue_url` when `run.source_context.type === "github_issue"` and show issue number/title in the established upstream visual style.
+
+- [ ] **Step 6: Run web checks**
+
+Run:
+
+```bash
+bun test app/routes/automations-new.test.tsx app/routes/runs.test.tsx
+bun run typecheck
+```
+
+Working directory: `apps/fabro-web`.
+
+Expected: PASS.
+
+## Task 10: Full Verification And Diff Review
+
+**Files:**
+- Review all changed files in `/Users/ipt/repos/fabro-fkukuck`
+
+- [ ] **Step 1: Run Rust formatting**
+
+Run:
+
+```bash
+cargo +nightly-2026-04-14 fmt --all
+```
+
+Expected: completes successfully and formats only intended Rust files.
+
+- [ ] **Step 2: Run targeted Rust tests**
+
+Run:
+
+```bash
+cargo nextest run -p fabro-automation -p fabro-types -p fabro-store -p fabro-github -p fabro-server -p fabro-api
+```
+
+Expected: PASS.
+
+- [ ] **Step 3: Run web checks**
+
+Run:
+
+```bash
+bun test
+bun run typecheck
+```
+
+Working directory: `apps/fabro-web`.
+
+Expected: PASS.
+
+- [ ] **Step 4: Verify no excluded legacy or Azure code was ported**
+
+Run:
+
+```bash
+git diff --name-only
+git diff --name-only | grep -E 'azure|sandboxd|github_issue_config|github_issue_orchestrator|github_issue_triggers|github\.toml' || true
+```
+
+Expected: no matches for excluded paths or legacy implementation files.
+
+- [ ] **Step 5: Review final diff**
+
+Run:
+
+```bash
+git diff --stat
+git diff
+```
+
+Expected: diff contains only automation-based GitHub issue intake, API/client updates generated from upstream, tests, and no Azure/fork-only code.
+
+## Self-Review
+
+- Spec coverage: covered trigger model, source metadata, trigger persistence, GitHub comments, server webhook dispatch, API/OpenAPI, TS client, web UI, and verification.
+- Exclusions: explicitly excluded legacy `github.toml` files and Azure/fork-only code.
+- Placeholder scan: no deferred implementation sections remain; each task names files, test commands, and concrete implementation content.
+- Type consistency: trigger type is consistently `github_issue`; run source context type is consistently `RunSourceContext::GithubIssue` / `type: "github_issue"`.
diff --git a/lib/crates/fabro-api/build.rs b/lib/crates/fabro-api/build.rs
index c87635923c..3d0881382a 100644
--- a/lib/crates/fabro-api/build.rs
+++ b/lib/crates/fabro-api/build.rs
@@ -468,6 +468,7 @@ fn main() {
         ("ModelFeatures", "fabro_model::ModelFeatures", &[]),
         ("ModelCosts", "fabro_model::ModelCosts", &[]),
         ("ModelTestMode", "fabro_model::ModelTestMode", &[]),
+        ("RunSourceContext", "fabro_types::RunSourceContext", &[]),
         ("RunProjection", "fabro_types::RunProjection", &[]),
         ("RunEvent", "fabro_types::RunEvent", &[]),
         ("PairId", "fabro_types::PairId", &[]),
@@ -625,6 +626,11 @@ fn main() {
             "fabro_automation::AutomationTrigger",
             &[],
         ),
+        (
+            "AutomationGithubIssueTrigger",
+            "fabro_automation::GithubIssueTrigger",
+            &[],
+        ),
         (
             "CreateAutomationRequest",
             "fabro_automation::AutomationDraft",
diff --git a/lib/crates/fabro-api/src/lib.rs b/lib/crates/fabro-api/src/lib.rs
index 8158838539..c884d3d337 100644
--- a/lib/crates/fabro-api/src/lib.rs
+++ b/lib/crates/fabro-api/src/lib.rs
@@ -17,6 +17,7 @@ pub mod types {
     pub use fabro_automation::{
         Automation, AutomationDraft as CreateAutomationRequest,
         AutomationReplace as ReplaceAutomationRequest, AutomationTarget, AutomationTrigger,
+        GithubIssueTrigger as AutomationGithubIssueTrigger,
     };
     pub use fabro_environment::Environment;
     pub use fabro_model::{
@@ -54,19 +55,19 @@ pub mod types {
         RunEvent, RunEventDetailContentKind, RunEventDetailResponse, RunFailure,
         RunPairStatusResponse, RunProjection, RunProvenance, RunRunnableSource, RunSandbox,
         RunSandboxFailure, RunSandboxInstance, RunSandboxKind, RunSandboxPlan, RunSandboxRuntime,
-        RunServerProvenance, RunSize, SandboxDetails, SandboxInfo, SandboxListMeta,
-        SandboxListResponse, SandboxNetwork, SandboxNetworkPolicy, SandboxNetworkPolicyMode,
-        SandboxProviderKind, SandboxProviderLookupError, SandboxResources, SandboxService,
-        SandboxServiceListResponse, SandboxState, SandboxTimestamps, SecretMetadata, SecretType,
-        ServerSettings, SessionDetail, SessionId, SessionMessage, SessionRecord, SessionStatus,
-        SessionSummary, SessionTurn, SkillsProjection, StageCompletion, StageContextWindow,
-        StageContextWindowBreakdownItem, StageContextWindowCategory, StageContextWindowCountMethod,
-        StageContextWindowProjection, StageContextWindowStaleness,
-        StageContextWindowUnavailableReason, StageContextWindowWarning, StageHandler,
-        StageModelUsage, StageOutcome, StageProjection, StageState, SubAgentProjection,
-        SubAgentStatus, SystemActorKind, SystemIntegrationStatus, SystemIntegrationsResponse,
-        TodoListProjection, TurnId, UpdateVariableRequest, UserPrincipal, Variable,
-        VariableListResponse, WorkflowSettings,
+        RunServerProvenance, RunSize, RunSourceContext, SandboxDetails, SandboxInfo,
+        SandboxListMeta, SandboxListResponse, SandboxNetwork, SandboxNetworkPolicy,
+        SandboxNetworkPolicyMode, SandboxProviderKind, SandboxProviderLookupError,
+        SandboxResources, SandboxService, SandboxServiceListResponse, SandboxState,
+        SandboxTimestamps, SecretMetadata, SecretType, ServerSettings, SessionDetail, SessionId,
+        SessionMessage, SessionRecord, SessionStatus, SessionSummary, SessionTurn,
+        SkillsProjection, StageCompletion, StageContextWindow, StageContextWindowBreakdownItem,
+        StageContextWindowCategory, StageContextWindowCountMethod, StageContextWindowProjection,
+        StageContextWindowStaleness, StageContextWindowUnavailableReason,
+        StageContextWindowWarning, StageHandler, StageModelUsage, StageOutcome, StageProjection,
+        StageState, SubAgentProjection, SubAgentStatus, SystemActorKind, SystemIntegrationStatus,
+        SystemIntegrationsResponse, TodoListProjection, TurnId, UpdateVariableRequest,
+        UserPrincipal, Variable, VariableListResponse, WorkflowSettings,
     };
 
     pub use crate::generated::types::*;
diff --git a/lib/crates/fabro-api/tests/automation_round_trip.rs b/lib/crates/fabro-api/tests/automation_round_trip.rs
index db4a66d03f..826080f46e 100644
--- a/lib/crates/fabro-api/tests/automation_round_trip.rs
+++ b/lib/crates/fabro-api/tests/automation_round_trip.rs
@@ -1,11 +1,12 @@
 use fabro_api::types::{
-    Automation as ApiAutomation, AutomationTarget as ApiAutomationTarget,
-    AutomationTrigger as ApiAutomationTrigger,
+    Automation as ApiAutomation, AutomationGithubIssueTrigger as ApiAutomationGithubIssueTrigger,
+    AutomationTarget as ApiAutomationTarget, AutomationTrigger as ApiAutomationTrigger,
     CreateAutomationRequest as ApiCreateAutomationRequest,
     ReplaceAutomationRequest as ApiReplaceAutomationRequest,
 };
 use fabro_automation::{
     Automation, AutomationDraft, AutomationReplace, AutomationTarget, AutomationTrigger,
+    AutomationTriggerId, GithubIssueTrigger,
 };
 use serde_json::json;
 
@@ -16,6 +17,7 @@ use serde_json::json;
 const _: fn(ApiAutomation) -> Automation = |value| value;
 const _: fn(ApiAutomationTarget) -> AutomationTarget = |value| value;
 const _: fn(ApiAutomationTrigger) -> AutomationTrigger = |value| value;
+const _: fn(ApiAutomationGithubIssueTrigger) -> GithubIssueTrigger = |value| value;
 const _: fn(ApiCreateAutomationRequest) -> AutomationDraft = |value| value;
 const _: fn(ApiReplaceAutomationRequest) -> AutomationReplace = |value| value;
 
@@ -42,11 +44,24 @@ fn automation_response_round_trips_public_json_shape() {
                 "type": "schedule",
                 "enabled": true,
                 "expression": "0 3 * * *"
+            },
+            {
+                "id": "github-issue",
+                "type": "github_issue",
+                "enabled": true,
+                "trigger_label": "fabro",
+                "issue_label": "Bug",
+                "comment": true
             }
         ]
     });
 
     let api: ApiAutomation = serde_json::from_value(value.clone()).unwrap();
+    assert!(matches!(
+        &api.triggers[2],
+        AutomationTrigger::GithubIssue(GithubIssueTrigger { id, .. })
+            if id == &AutomationTriggerId::new("github-issue").unwrap()
+    ));
     assert_eq!(serde_json::to_value(api).unwrap(), value);
 }
 
diff --git a/lib/crates/fabro-api/tests/run_projection_round_trip.rs b/lib/crates/fabro-api/tests/run_projection_round_trip.rs
index 9a2a0f3100..9ec35bba6b 100644
--- a/lib/crates/fabro-api/tests/run_projection_round_trip.rs
+++ b/lib/crates/fabro-api/tests/run_projection_round_trip.rs
@@ -1,12 +1,17 @@
 use std::any::{TypeId, type_name};
 
-use fabro_api::types::RunProjection as ApiRunProjection;
-use fabro_types::{Graph, RunProjection, RunSpec, WorkflowSettings};
+use fabro_api::types::{
+    RunProjection as ApiRunProjection, RunSourceContext as ApiRunSourceContext,
+};
+use fabro_types::{
+    GithubIssueRunSource, Graph, RunProjection, RunSourceContext, RunSpec, WorkflowSettings,
+};
 use serde_json::json;
 
 #[test]
 fn run_projection_reuses_canonical_type() {
     assert_same_type::<ApiRunProjection, RunProjection>();
+    assert_same_type::<ApiRunSourceContext, RunSourceContext>();
 }
 
 #[test]
@@ -135,6 +140,12 @@ fn run_spec_json() -> serde_json::Value {
         graph_source:     Some("digraph test {}".to_string()),
         workflow_slug:    None,
         automation:       None,
+        source_context:   Some(RunSourceContext::GithubIssue(GithubIssueRunSource {
+            repository:   "owner/repo".to_string(),
+            issue_number: 42,
+            issue_title:  "Fix bug".to_string(),
+            issue_url:    "https://github.com/owner/repo/issues/42".to_string(),
+        })),
         source_directory: None,
         labels:           std::collections::HashMap::new(),
         provenance:       None,
diff --git a/lib/crates/fabro-api/tests/run_summary_round_trip.rs b/lib/crates/fabro-api/tests/run_summary_round_trip.rs
index 7984489419..2ca0856a47 100644
--- a/lib/crates/fabro-api/tests/run_summary_round_trip.rs
+++ b/lib/crates/fabro-api/tests/run_summary_round_trip.rs
@@ -9,10 +9,10 @@ use fabro_api::types::{
 };
 use fabro_types::status::{RunStatus, SuccessReason};
 use fabro_types::{
-    AskFabro, AskFabroUnavailableReason, AutomationRef, DiffSummary, PullRequestLink,
-    RepositoryProvider, RepositoryRef, Run, RunApproval, RunApprovalState, RunBillingSummary,
-    RunId, RunLifecycle, RunLinks, RunOrigin, RunRunnableSource, RunSize, RunTimestamps, RunTiming,
-    WorkflowRef, fixtures,
+    AskFabro, AskFabroUnavailableReason, AutomationRef, DiffSummary, GithubIssueRunSource,
+    PullRequestLink, RepositoryProvider, RepositoryRef, Run, RunApproval, RunApprovalState,
+    RunBillingSummary, RunId, RunLifecycle, RunLinks, RunOrigin, RunRunnableSource, RunSize,
+    RunSourceContext, RunTimestamps, RunTiming, WorkflowRef, fixtures,
 };
 use serde_json::json;
 
@@ -83,6 +83,12 @@ fn run_summary_json_matches_openapi_shape() {
             name:       Some("Nightly".to_string()),
             trigger_id: Some("schedule_1".to_string()),
         }),
+        source_context:   Some(RunSourceContext::GithubIssue(GithubIssueRunSource {
+            repository:   "owner/repo".to_string(),
+            issue_number: 42,
+            issue_title:  "Fix bug".to_string(),
+            issue_url:    "https://github.com/owner/repo/issues/42".to_string(),
+        })),
         repository:       Some(RepositoryRef {
             name:       "fabro".to_string(),
             origin_url: None,
@@ -156,6 +162,13 @@ fn run_summary_json_matches_openapi_shape() {
                 "name": "Nightly",
                 "trigger_id": "schedule_1"
             },
+            "source_context": {
+                "type": "github_issue",
+                "repository": "owner/repo",
+                "issue_number": 42,
+                "issue_title": "Fix bug",
+                "issue_url": "https://github.com/owner/repo/issues/42"
+            },
             "repository": {
                 "name": "fabro",
                 "origin_url": null,
@@ -277,6 +290,7 @@ fn run_summary_deserializes_when_optional_fields_are_absent() {
     assert_eq!(summary.title, "ship it");
     assert_eq!(summary.labels, HashMap::new());
     assert_eq!(summary.source_directory, None);
+    assert_eq!(summary.source_context, None);
     assert_eq!(
         summary.repository,
         Some(RepositoryRef {
diff --git a/lib/crates/fabro-automation/src/lib.rs b/lib/crates/fabro-automation/src/lib.rs
index 4dd253cbc2..a57370866f 100644
--- a/lib/crates/fabro-automation/src/lib.rs
+++ b/lib/crates/fabro-automation/src/lib.rs
@@ -7,6 +7,6 @@ pub use error::{AutomationStoreError, AutomationValidationError};
 pub use id::{AutomationId, AutomationRevision, AutomationRevisionParseError, AutomationTriggerId};
 pub use model::{
     ApiTrigger, Automation, AutomationDraft, AutomationReplace, AutomationTarget,
-    AutomationTrigger, ScheduleTrigger, parse_schedule_expression,
+    AutomationTrigger, GithubIssueTrigger, ScheduleTrigger, parse_schedule_expression,
 };
 pub use store::AutomationStore;
diff --git a/lib/crates/fabro-automation/src/model.rs b/lib/crates/fabro-automation/src/model.rs
index b110f69c87..69e3528c7e 100644
--- a/lib/crates/fabro-automation/src/model.rs
+++ b/lib/crates/fabro-automation/src/model.rs
@@ -28,6 +28,10 @@ pub fn parse_schedule_expression(expression: &str) -> Result<Cron, CronError> {
     SCHEDULE_CRON_PARSER.parse(expression)
 }
 
+fn default_true() -> bool {
+    true
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(deny_unknown_fields)]
 pub struct Automation {
@@ -102,6 +106,16 @@ impl Automation {
             })
     }
 
+    /// Iterate the enabled GitHub issue triggers.
+    pub fn enabled_github_issue_triggers(&self) -> impl Iterator<Item = &GithubIssueTrigger> {
+        self.triggers
+            .iter()
+            .filter_map(move |trigger| match trigger {
+                AutomationTrigger::GithubIssue(trigger) if trigger.enabled => Some(trigger),
+                _ => None,
+            })
+    }
+
     fn from_persisted(
         id: AutomationId,
         revision: AutomationRevision,
@@ -142,6 +156,7 @@ pub struct AutomationTarget {
 pub enum AutomationTrigger {
     Api(ApiTrigger),
     Schedule(ScheduleTrigger),
+    GithubIssue(GithubIssueTrigger),
 }
 
 impl AutomationTrigger {
@@ -150,6 +165,7 @@ impl AutomationTrigger {
         match self {
             Self::Api(trigger) => &trigger.id,
             Self::Schedule(trigger) => &trigger.id,
+            Self::GithubIssue(trigger) => &trigger.id,
         }
     }
 
@@ -158,6 +174,7 @@ impl AutomationTrigger {
         match self {
             Self::Api(trigger) => trigger.enabled,
             Self::Schedule(trigger) => trigger.enabled,
+            Self::GithubIssue(trigger) => trigger.enabled,
         }
     }
 }
@@ -177,6 +194,18 @@ pub struct ScheduleTrigger {
     pub expression: String,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct GithubIssueTrigger {
+    pub id:            AutomationTriggerId,
+    pub enabled:       bool,
+    pub trigger_label: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub issue_label:   Option<String>,
+    #[serde(default = "default_true")]
+    pub comment:       bool,
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(deny_unknown_fields)]
 pub struct AutomationDraft {
@@ -395,6 +424,7 @@ fn validate_triggers(triggers: &[AutomationTrigger]) -> Result<(), AutomationVal
                     }
                 })?;
             }
+            AutomationTrigger::GithubIssue(_) => {}
         }
     }
 
@@ -405,7 +435,7 @@ fn validate_triggers(triggers: &[AutomationTrigger]) -> Result<(), AutomationVal
 mod tests {
     use crate::{
         ApiTrigger, Automation, AutomationId, AutomationReplace, AutomationTarget,
-        AutomationTrigger, AutomationTriggerId, ScheduleTrigger,
+        AutomationTrigger, AutomationTriggerId, GithubIssueTrigger, ScheduleTrigger,
     };
 
     fn target() -> AutomationTarget {
@@ -515,6 +545,46 @@ enabled = true
         assert_eq!(trigger_ids, vec!["nightly"]);
     }
 
+    #[test]
+    fn github_issue_trigger_round_trips() {
+        let trigger = AutomationTrigger::GithubIssue(GithubIssueTrigger {
+            id:            AutomationTriggerId::new("github-issue").unwrap(),
+            enabled:       true,
+            trigger_label: "fabro".to_string(),
+            issue_label:   Some("Bug".to_string()),
+            comment:       true,
+        });
+
+        let value = toml::Value::try_from(&trigger).unwrap();
+        let parsed: AutomationTrigger = value.try_into().unwrap();
+
+        assert_eq!(parsed, trigger);
+    }
+
+    #[test]
+    fn github_issue_trigger_defaults_comment_to_true() {
+        let parsed: AutomationTrigger = toml::from_str(
+            r#"
+            type = "github_issue"
+            id = "github-issue"
+            enabled = true
+            trigger_label = "fabro"
+            "#,
+        )
+        .unwrap();
+
+        assert_eq!(
+            parsed,
+            AutomationTrigger::GithubIssue(GithubIssueTrigger {
+                id:            AutomationTriggerId::new("github-issue").unwrap(),
+                enabled:       true,
+                trigger_label: "fabro".to_string(),
+                issue_label:   None,
+                comment:       true,
+            })
+        );
+    }
+
     #[test]
     fn validation_rejects_invalid_inputs() {
         let cases = [
diff --git a/lib/crates/fabro-github/src/lib.rs b/lib/crates/fabro-github/src/lib.rs
index bac1f5fbc0..f980b6dca2 100644
--- a/lib/crates/fabro-github/src/lib.rs
+++ b/lib/crates/fabro-github/src/lib.rs
@@ -626,6 +626,35 @@ pub async fn create_installation_access_token_for_pr(
     .await
 }
 
+/// Create a GitHub issue comment with an installation or PAT bearer token.
+pub async fn create_issue_comment(
+    client: &impl HttpClient,
+    token: &str,
+    owner: &str,
+    repo: &str,
+    issue_number: u64,
+    body: &str,
+    base_url: &str,
+) -> anyhow::Result<()> {
+    let url = format!("{base_url}/repos/{owner}/{repo}/issues/{issue_number}/comments");
+    let auth = format!("Bearer {token}");
+    let body = serde_json::json!({ "body": body });
+    let resp = client
+        .request(HttpMethod::Post, &url, &github_headers(&auth), Some(&body))
+        .await
+        .with_context(|| {
+            format!("failed to create issue comment on {owner}/{repo}#{issue_number}")
+        })?;
+
+    match resp.status {
+        200 | 201 => Ok(()),
+        status => bail!(
+            "Unexpected status {status} creating issue comment on {owner}/{repo}#{issue_number}: {}",
+            resp.text()
+        ),
+    }
+}
+
 /// Result of a successful pull request creation.
 pub struct CreatedPullRequest {
     pub html_url: String,
@@ -1710,6 +1739,32 @@ mod tests {
         }
     }
 
+    #[tokio::test]
+    async fn create_issue_comment_posts_body() {
+        let body = "Fabro started run https://fabro.example/runs/01";
+        let mock = MockHttpClient::new()
+            .on(
+                HttpMethod::Post,
+                "/repos/owner/repo/issues/123/comments",
+                201,
+                r#"{}"#,
+            )
+            .with_req_header("Authorization", "Bearer test-token")
+            .with_req_body(&serde_json::json!({ "body": body }).to_string());
+
+        create_issue_comment(
+            &mock,
+            "test-token",
+            "owner",
+            "repo",
+            123,
+            body,
+            "https://api.github.test",
+        )
+        .await
+        .unwrap();
+    }
+
     // -----------------------------------------------------------------------
     // create_installation_access_token — success
     // -----------------------------------------------------------------------
diff --git a/lib/crates/fabro-server/src/automation_materializer.rs b/lib/crates/fabro-server/src/automation_materializer.rs
index 52eb7ea682..ae9c467b7b 100644
--- a/lib/crates/fabro-server/src/automation_materializer.rs
+++ b/lib/crates/fabro-server/src/automation_materializer.rs
@@ -1,3 +1,4 @@
+use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
 use std::time::Duration;
@@ -6,7 +7,7 @@ use anyhow::Context as _;
 use async_trait::async_trait;
 use base64::Engine as _;
 use base64::engine::general_purpose::STANDARD as BASE64_STANDARD;
-use fabro_api::types::RunManifest;
+use fabro_api::types::{ManifestArgs, RunManifest};
 use fabro_automation::{AutomationId, AutomationTarget};
 use fabro_config::{EnvironmentLayer, MergeMap};
 use fabro_manifest::ManifestBuildInput;
@@ -22,13 +23,15 @@ const GIT_WORKTREE_ADD_TIMEOUT: Duration = Duration::from_secs(30);
 const GIT_WORKTREE_PRUNE_TIMEOUT: Duration = Duration::from_secs(10);
 const GIT_REV_PARSE_TIMEOUT: Duration = Duration::from_secs(10);
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq)]
 pub(crate) struct AutomationRunMaterializeInput {
     pub automation_id:      AutomationId,
     pub target:             AutomationTarget,
     pub run_id:             RunId,
     pub user_settings_path: PathBuf,
     pub temp_root:          PathBuf,
+    pub input_overrides:    HashMap<String, toml::Value>,
+    pub title_override:     Option<String>,
 }
 
 #[derive(Debug, Clone)]
@@ -601,17 +604,25 @@ fn build_manifest_from_checkout(
         checked_out_sha,
         environment_defaults,
     } = args;
-    let built = fabro_manifest::build_run_manifest(ManifestBuildInput {
+    let manifest_input = ManifestBuildInput {
         workflow: input.target.workflow.as_str().into(),
         cwd: checkout_dir,
         run_id: Some(input.run_id),
         user_settings_path: Some(input.user_settings_path),
         environment_defaults,
+        input_overrides: input.input_overrides.clone(),
         ..ManifestBuildInput::default()
-    })
-    .map_err(|err| manifest_build_error(&err))?;
+    };
+    let submitted_input_overrides = manifest_input.input_overrides.clone();
+    let built = fabro_manifest::build_run_manifest(manifest_input)
+        .map_err(|err| manifest_build_error(&err))?;
 
     let mut manifest = built.manifest;
+    if let Some(title) = input.title_override.clone() {
+        manifest.title = Some(title.try_into().map_err(|err| {
+            AutomationRunMaterializeError::Manifest(format!("invalid automation run title: {err}"))
+        })?);
+    }
     manifest.git = Some(GitContext {
         origin_url:   github_metadata_url(&repo),
         branch:       input.target.ref_selector,
@@ -619,6 +630,12 @@ fn build_manifest_from_checkout(
         dirty:        DirtyStatus::Clean,
         push_outcome: PreRunPushOutcome::NotAttempted,
     });
+    if !submitted_input_overrides.is_empty() {
+        manifest.args = Some(ManifestArgs {
+            input: input_overrides_as_args(&submitted_input_overrides),
+            ..ManifestArgs::default()
+        });
+    }
     let submitted_manifest_bytes = serde_json::to_vec(&manifest)
         .with_context(|| {
             format!(
@@ -633,6 +650,22 @@ fn build_manifest_from_checkout(
     })
 }
 
+fn input_overrides_as_args(input_overrides: &HashMap<String, toml::Value>) -> Vec<String> {
+    let mut args = input_overrides
+        .iter()
+        .map(|(key, value)| format!("{key}={}", input_override_arg_value(value)))
+        .collect::<Vec<_>>();
+    args.sort();
+    args
+}
+
+fn input_override_arg_value(value: &toml::Value) -> String {
+    match value {
+        toml::Value::String(value) => value.clone(),
+        value => value.to_string(),
+    }
+}
+
 fn manifest_build_error(error: &anyhow::Error) -> AutomationRunMaterializeError {
     if error.chain().any(|source| {
         source
@@ -655,6 +688,7 @@ pub struct TestAutomationRunMaterializer {
 struct TestAutomationRunMaterializerState {
     captured_inputs: Vec<AutomationRunMaterializeInput>,
     response:        Result<AutomationRunMaterialized, AutomationRunMaterializeError>,
+    delay:           Option<std::time::Duration>,
 }
 
 #[cfg(any(test, feature = "test-support"))]
@@ -666,6 +700,20 @@ impl TestAutomationRunMaterializer {
         }))
     }
 
+    pub fn succeed_after(
+        manifest: RunManifest,
+        submitted_manifest_bytes: Vec<u8>,
+        delay: std::time::Duration,
+    ) -> Self {
+        let materializer = Self::succeed(manifest, submitted_manifest_bytes);
+        materializer
+            .inner
+            .lock()
+            .expect("test automation materializer lock poisoned")
+            .delay = Some(delay);
+        materializer
+    }
+
     pub fn fail_invalid_target(message: impl Into<String>) -> Self {
         Self::new(Err(AutomationRunMaterializeError::InvalidTarget(
             message.into(),
@@ -677,6 +725,7 @@ impl TestAutomationRunMaterializer {
             inner: std::sync::Arc::new(std::sync::Mutex::new(TestAutomationRunMaterializerState {
                 captured_inputs: Vec::new(),
                 response,
+                delay: None,
             })),
         }
     }
@@ -701,12 +750,18 @@ impl AutomationRunMaterializer for TestAutomationRunMaterializer {
         &self,
         input: AutomationRunMaterializeInput,
     ) -> Result<AutomationRunMaterialized, AutomationRunMaterializeError> {
-        let mut guard = self
-            .inner
-            .lock()
-            .expect("test automation materializer lock poisoned");
-        guard.captured_inputs.push(input);
-        guard.response.clone()
+        let (response, delay) = {
+            let mut guard = self
+                .inner
+                .lock()
+                .expect("test automation materializer lock poisoned");
+            guard.captured_inputs.push(input);
+            (guard.response.clone(), guard.delay)
+        };
+        if let Some(delay) = delay {
+            tokio::time::sleep(delay).await;
+        }
+        response
     }
 }
 
@@ -917,6 +972,8 @@ mod tests {
                 run_id,
                 user_settings_path: user_settings_path.clone(),
                 temp_root: temp.path().to_path_buf(),
+                input_overrides: HashMap::new(),
+                title_override: None,
             },
             checkout_dir: checkout.clone(),
             repo,
diff --git a/lib/crates/fabro-server/src/automation_runner.rs b/lib/crates/fabro-server/src/automation_runner.rs
new file mode 100644
index 0000000000..5c8318376f
--- /dev/null
+++ b/lib/crates/fabro-server/src/automation_runner.rs
@@ -0,0 +1,221 @@
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use axum::http::{HeaderMap, StatusCode};
+use fabro_automation::{Automation, AutomationTriggerId};
+use fabro_types::{AutomationRef, Principal, RunId, RunSourceContext};
+
+use crate::automation_materializer::{
+    AutomationRunMaterializeError, AutomationRunMaterializeInput,
+};
+use crate::error::ApiError;
+use crate::server::AppState;
+use crate::server::handler::{lifecycle, runs};
+
+#[cfg(any(test, feature = "test-support"))]
+pub(crate) type AutomationRunStartOverride =
+    Arc<dyn Fn(RunId) -> Result<(), ApiError> + Send + Sync>;
+
+pub(crate) struct FireAutomationRunInput {
+    pub(crate) automation:      Automation,
+    pub(crate) trigger_id:      AutomationTriggerId,
+    pub(crate) actor:           Principal,
+    pub(crate) headers:         HeaderMap,
+    pub(crate) input_overrides: HashMap<String, toml::Value>,
+    pub(crate) title_override:  Option<String>,
+    pub(crate) source_context:  Option<RunSourceContext>,
+}
+
+pub(crate) struct FiredAutomationRun {
+    pub(crate) created:      runs::CreatedRunFromManifest,
+    pub(crate) start_result: Result<(), ApiError>,
+}
+
+#[derive(Debug)]
+pub(crate) enum FireAutomationRunError {
+    Materialize(AutomationRunMaterializeError),
+    Create(ApiError),
+}
+
+impl FireAutomationRunError {
+    pub(crate) fn into_api_error(self) -> ApiError {
+        match self {
+            Self::Materialize(err) => {
+                ApiError::new(StatusCode::UNPROCESSABLE_ENTITY, err.to_string())
+            }
+            Self::Create(err) => err,
+        }
+    }
+}
+
+pub(crate) async fn fire_automation_run(
+    state: Arc<AppState>,
+    input: FireAutomationRunInput,
+) -> Result<FiredAutomationRun, FireAutomationRunError> {
+    let FireAutomationRunInput {
+        automation,
+        trigger_id,
+        actor,
+        headers,
+        input_overrides,
+        title_override,
+        source_context,
+    } = input;
+    let run_id = RunId::new();
+    let materialized = state
+        .materialize_automation_run(AutomationRunMaterializeInput {
+            automation_id: automation.id.clone(),
+            target: automation.target.clone(),
+            run_id,
+            user_settings_path: state.active_config_path().to_path_buf(),
+            temp_root: state.automation_temp_root(),
+            input_overrides,
+            title_override,
+        })
+        .await
+        .map_err(FireAutomationRunError::Materialize)?;
+    let explicit_title_supplied = materialized.manifest.title.is_some();
+    let automation_ref = AutomationRef {
+        id:         automation.id.to_string(),
+        name:       Some(automation.name.clone()),
+        trigger_id: Some(trigger_id.to_string()),
+    };
+
+    let created = Box::pin(runs::create_run_from_manifest(
+        Arc::clone(&state),
+        runs::CreateRunFromManifestRequest {
+            manifest: materialized.manifest,
+            submitted_manifest_bytes: materialized.submitted_manifest_bytes,
+            explicit_run_id: Some(run_id),
+            explicit_title_supplied,
+            actor: actor.clone(),
+            headers,
+            automation: Some(automation_ref),
+            source_context,
+        },
+    ))
+    .await
+    .map_err(FireAutomationRunError::Create)?;
+
+    #[cfg(any(test, feature = "test-support"))]
+    let start_result = if let Some(start_override) = state.automation_run_start_override.as_ref() {
+        start_override(run_id)
+    } else {
+        lifecycle::queue_run_start(state.as_ref(), run_id, false, actor).await
+    };
+    #[cfg(not(any(test, feature = "test-support")))]
+    let start_result = lifecycle::queue_run_start(state.as_ref(), run_id, false, actor).await;
+    Ok(FiredAutomationRun {
+        created,
+        start_result,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use axum::http::HeaderMap;
+    use fabro_api::types::RunManifest;
+    use fabro_automation::{
+        ApiTrigger, AutomationId, AutomationRevision, AutomationTarget, AutomationTrigger,
+    };
+    use fabro_types::{GithubIssueRunSource, SystemActorKind};
+    use serde_json::json;
+
+    use super::*;
+    use crate::test_support::{TestAppStateBuilder, TestAutomationRunMaterializer};
+
+    fn minimal_manifest() -> RunManifest {
+        serde_json::from_value(json!({
+            "version": 1,
+            "cwd": "/tmp",
+            "target": {
+                "identifier": "workflow.fabro",
+                "path": "workflow.fabro"
+            },
+            "workflows": {
+                "workflow.fabro": {
+                    "source": r#"digraph Test {
+                        graph [goal="Test"]
+                        start [shape=Mdiamond]
+                        exit  [shape=Msquare]
+                        start -> exit
+                    }"#,
+                    "files": {}
+                }
+            }
+        }))
+        .expect("minimal manifest should deserialize")
+    }
+
+    fn test_automation(id: &str, name: &str, trigger_id: AutomationTriggerId) -> Automation {
+        Automation {
+            id:          AutomationId::new(id).expect("test automation id should be valid"),
+            revision:    AutomationRevision::from_bytes(format!("{id}:{name}").as_bytes()),
+            name:        name.to_string(),
+            description: None,
+            target:      AutomationTarget {
+                repository:   "fabro-sh/fabro".to_string(),
+                ref_selector: "main".to_string(),
+                workflow:     "workflow.fabro".to_string(),
+            },
+            triggers:    vec![AutomationTrigger::Api(ApiTrigger {
+                id:      trigger_id,
+                enabled: true,
+            })],
+        }
+    }
+
+    #[tokio::test]
+    async fn fire_automation_run_creates_started_run_with_automation_ref() {
+        let manifest = minimal_manifest();
+        let submitted_manifest_bytes = serde_json::to_vec(&manifest).unwrap();
+        let materializer =
+            TestAutomationRunMaterializer::succeed(manifest, submitted_manifest_bytes);
+        let state = TestAppStateBuilder::new()
+            .automation_materializer(materializer)
+            .build();
+        let automation = test_automation(
+            "issue-bug",
+            "Implement bug",
+            AutomationTriggerId::new("bug").unwrap(),
+        );
+        let source_context = RunSourceContext::GithubIssue(GithubIssueRunSource {
+            repository:   "fabro-sh/fabro".to_string(),
+            issue_number: 42,
+            issue_title:  "Bug report".to_string(),
+            issue_url:    "https://github.com/fabro-sh/fabro/issues/42".to_string(),
+        });
+
+        let fired = fire_automation_run(Arc::clone(&state), FireAutomationRunInput {
+            automation:      automation.clone(),
+            trigger_id:      AutomationTriggerId::new("bug").unwrap(),
+            actor:           Principal::System {
+                system_kind: SystemActorKind::Engine,
+            },
+            headers:         HeaderMap::new(),
+            input_overrides: HashMap::new(),
+            title_override:  None,
+            source_context:  Some(source_context.clone()),
+        })
+        .await
+        .expect("automation run should fire");
+
+        assert!(fired.start_result.is_ok());
+        assert_eq!(fired.created.run_id, fired.created.summary.id);
+        assert_eq!(
+            fired.created.summary.automation.clone().unwrap().id,
+            "issue-bug"
+        );
+        assert_eq!(
+            fired
+                .created
+                .summary
+                .automation
+                .unwrap()
+                .trigger_id
+                .as_deref(),
+            Some("bug")
+        );
+        assert_eq!(fired.created.summary.source_context, Some(source_context));
+    }
+}
diff --git a/lib/crates/fabro-server/src/demo/mod.rs b/lib/crates/fabro-server/src/demo/mod.rs
index d189b2a21e..4758e0a4c1 100644
--- a/lib/crates/fabro-server/src/demo/mod.rs
+++ b/lib/crates/fabro-server/src/demo/mod.rs
@@ -1167,6 +1167,7 @@ mod runs {
                 edge_count: 0,
             },
             automation: None,
+            source_context: None,
             repository: Some(RepositoryRef::from_origin_and_source(
                 repo_origin_url,
                 source_directory.as_deref(),
diff --git a/lib/crates/fabro-server/src/github_issue_automation_trigger.rs b/lib/crates/fabro-server/src/github_issue_automation_trigger.rs
new file mode 100644
index 0000000000..849fba06de
--- /dev/null
+++ b/lib/crates/fabro-server/src/github_issue_automation_trigger.rs
@@ -0,0 +1,463 @@
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use axum::http::HeaderMap;
+use chrono::Utc;
+use fabro_automation::{Automation, AutomationTrigger, GithubIssueTrigger};
+use fabro_store::{
+    AutomationEventSource, AutomationTriggerKind, AutomationTriggerRunContext,
+    AutomationTriggerRunRecord, AutomationTriggerRunStatus, GithubIssueTriggerCycleKey,
+    TriggerStartDecision,
+};
+use fabro_types::{GithubIssueRunSource, Principal, RunId, RunSourceContext};
+use tracing::warn;
+
+use crate::automation_materializer::AutomationRunMaterializeError;
+use crate::automation_runner::{
+    FireAutomationRunError, FireAutomationRunInput, fire_automation_run,
+};
+use crate::github_issue_events::{
+    GithubIssueRunInputs, GithubIssueWebhookEvent, parse_issue_event,
+};
+use crate::server::AppState;
+
+pub(crate) async fn handle_github_issue_webhook(
+    state: Arc<AppState>,
+    headers: HeaderMap,
+    delivery_id: String,
+    body: &[u8],
+) {
+    let Some(event_type) = headers
+        .get("x-github-event")
+        .and_then(|value| value.to_str().ok())
+    else {
+        return;
+    };
+    if event_type != "issues" {
+        return;
+    }
+
+    let Ok(event) = parse_issue_event(body) else {
+        warn!(delivery_id, "Failed to parse GitHub issue webhook payload");
+        return;
+    };
+    if event.is_pull_request() {
+        return;
+    }
+
+    match event.action.as_str() {
+        "labeled" => handle_labeled(state, headers, delivery_id, event).await,
+        "unlabeled" => handle_unlabeled(state, delivery_id, event).await,
+        _ => {}
+    }
+}
+
+async fn handle_labeled(
+    state: Arc<AppState>,
+    headers: HeaderMap,
+    delivery_id: String,
+    event: GithubIssueWebhookEvent,
+) {
+    let matches = matching_github_issue_triggers(&state.automation_store().list().await, &event);
+
+    for (automation, trigger) in matches {
+        let key = cycle_key(&automation, &trigger, &event);
+        let trigger_event_id = trigger_event_id(&delivery_id, &automation, &trigger);
+        let Ok(trigger_runs) = state.store_ref().automation_trigger_runs().await else {
+            warn!(delivery_id, "Failed to open automation trigger run store");
+            continue;
+        };
+        let decision = trigger_runs
+            .decide_github_issue_start(&key, &trigger_event_id)
+            .await;
+        let Ok(TriggerStartDecision::Start { .. }) = decision else {
+            if let Err(err) = decision {
+                warn!(error = %err, delivery_id, "Failed to decide GitHub issue automation trigger start");
+            }
+            continue;
+        };
+
+        tokio::spawn(fire_labeled_automation(
+            Arc::clone(&state),
+            headers.clone(),
+            delivery_id.clone(),
+            automation,
+            trigger,
+            event.clone(),
+            trigger_event_id,
+        ));
+    }
+}
+
+async fn fire_labeled_automation(
+    state: Arc<AppState>,
+    headers: HeaderMap,
+    delivery_id: String,
+    automation: Automation,
+    trigger: GithubIssueTrigger,
+    event: GithubIssueWebhookEvent,
+    trigger_event_id: String,
+) {
+    let comment_token = if trigger.comment {
+        match github_token(&state, &event).await {
+            Ok(token) => Some(token),
+            Err(err) => {
+                warn!(error = %err, delivery_id, "Failed to resolve GitHub issue automation comment token");
+                None
+            }
+        }
+    } else {
+        None
+    };
+    let inputs = event.run_inputs(&trigger.trigger_label, &delivery_id);
+    let fired = fire_automation_run(Arc::clone(&state), FireAutomationRunInput {
+        automation: automation.clone(),
+        trigger_id: trigger.id.clone(),
+        actor: Principal::Webhook {
+            delivery_id: delivery_id.clone(),
+        },
+        headers,
+        input_overrides: issue_inputs_to_toml(&inputs),
+        title_override: Some(event.issue.title.clone()),
+        source_context: Some(RunSourceContext::GithubIssue(GithubIssueRunSource {
+            repository:   event.repository.full_name.clone(),
+            issue_number: event.issue.number,
+            issue_title:  event.issue.title.clone(),
+            issue_url:    event.issue.html_url.clone(),
+        })),
+    })
+    .await;
+
+    match fired {
+        Ok(fired) => {
+            let run_id = Some(fired.created.run_id);
+            if fired.start_result.is_ok() {
+                record_trigger_run(
+                    &state,
+                    &automation,
+                    &trigger,
+                    &event,
+                    &trigger_event_id,
+                    run_id,
+                    AutomationTriggerRunStatus::Started,
+                )
+                .await;
+                if trigger.comment {
+                    post_success_comment(
+                        &state,
+                        comment_token.as_deref(),
+                        &event,
+                        &automation.name,
+                        run_id.unwrap(),
+                        fired.created.summary.links.web.as_deref(),
+                    )
+                    .await;
+                }
+            } else {
+                record_trigger_run(
+                    &state,
+                    &automation,
+                    &trigger,
+                    &event,
+                    &trigger_event_id,
+                    run_id,
+                    AutomationTriggerRunStatus::FailedToStart,
+                )
+                .await;
+                if trigger.comment {
+                    post_failure_comment(
+                        &state,
+                        comment_token.as_deref(),
+                        &event,
+                        failure_comment(&automation.name, "run start failed"),
+                    )
+                    .await;
+                }
+            }
+        }
+        Err(err) => {
+            warn!(error = ?err, delivery_id, "Failed to create GitHub issue automation run");
+            record_trigger_run(
+                &state,
+                &automation,
+                &trigger,
+                &event,
+                &trigger_event_id,
+                None,
+                AutomationTriggerRunStatus::FailedToStart,
+            )
+            .await;
+            if trigger.comment {
+                let reason = fire_automation_run_failure_reason(&err);
+                post_failure_comment(
+                    &state,
+                    comment_token.as_deref(),
+                    &event,
+                    failure_comment(&automation.name, reason),
+                )
+                .await;
+            }
+        }
+    }
+}
+
+async fn handle_unlabeled(
+    state: Arc<AppState>,
+    delivery_id: String,
+    event: GithubIssueWebhookEvent,
+) {
+    let matches = matching_github_issue_triggers(&state.automation_store().list().await, &event);
+    for (automation, trigger) in matches {
+        let trigger_runs = match state.store_ref().automation_trigger_runs().await {
+            Ok(trigger_runs) => trigger_runs,
+            Err(err) => {
+                warn!(error = %err, delivery_id, "Failed to open automation trigger run store");
+                continue;
+            }
+        };
+        if let Err(err) = trigger_runs
+            .close_github_issue_cycle(&cycle_key(&automation, &trigger, &event))
+            .await
+        {
+            warn!(error = %err, delivery_id, "Failed to close GitHub issue automation trigger cycle");
+        }
+    }
+}
+
+fn matching_github_issue_triggers(
+    automations: &[Automation],
+    event: &GithubIssueWebhookEvent,
+) -> Vec<(Automation, GithubIssueTrigger)> {
+    let Some(changed_label) = event.added_label_name() else {
+        return Vec::new();
+    };
+    let issue_labels = event.issue_label_names();
+    let mut matches = Vec::new();
+    for automation in automations {
+        if automation.target.repository != event.repository.full_name {
+            continue;
+        }
+        for trigger in &automation.triggers {
+            let AutomationTrigger::GithubIssue(trigger) = trigger else {
+                continue;
+            };
+            if trigger.enabled
+                && trigger.trigger_label == changed_label
+                && trigger
+                    .issue_label
+                    .as_ref()
+                    .is_none_or(|label| issue_labels.contains(label))
+            {
+                matches.push((automation.clone(), trigger.clone()));
+            }
+        }
+    }
+    matches
+}
+
+fn cycle_key(
+    automation: &Automation,
+    trigger: &GithubIssueTrigger,
+    event: &GithubIssueWebhookEvent,
+) -> GithubIssueTriggerCycleKey {
+    GithubIssueTriggerCycleKey {
+        automation_id: automation.id.clone(),
+        trigger_id:    trigger.id.clone(),
+        repository:    event.repository.full_name.clone(),
+        issue_number:  event.issue.number,
+    }
+}
+
+fn trigger_event_id(
+    delivery_id: &str,
+    automation: &Automation,
+    trigger: &GithubIssueTrigger,
+) -> String {
+    format!("{delivery_id}:{}:{}", automation.id, trigger.id)
+}
+
+async fn record_trigger_run(
+    state: &AppState,
+    automation: &Automation,
+    trigger: &GithubIssueTrigger,
+    event: &GithubIssueWebhookEvent,
+    delivery_id: &str,
+    run_id: Option<RunId>,
+    status: AutomationTriggerRunStatus,
+) {
+    let record = AutomationTriggerRunRecord {
+        automation_id: automation.id.clone(),
+        trigger_id: trigger.id.clone(),
+        trigger_type: AutomationTriggerKind::GithubIssue,
+        event_source: AutomationEventSource::Github,
+        event_id: delivery_id.to_string(),
+        run_id,
+        status,
+        created_at: Utc::now(),
+        closed_at: None,
+        context: AutomationTriggerRunContext::GithubIssue {
+            repository:    event.repository.full_name.clone(),
+            issue_number:  event.issue.number,
+            trigger_label: trigger.trigger_label.clone(),
+            issue_label:   trigger.issue_label.clone(),
+        },
+    };
+    let trigger_runs = match state.store_ref().automation_trigger_runs().await {
+        Ok(trigger_runs) => trigger_runs,
+        Err(err) => {
+            warn!(error = %err, "Failed to open automation trigger run store");
+            return;
+        }
+    };
+    let result = match status {
+        AutomationTriggerRunStatus::Started => trigger_runs.record_started(record).await,
+        AutomationTriggerRunStatus::FailedToStart => {
+            trigger_runs.record_failed_to_start(record).await
+        }
+    };
+    if let Err(err) = result {
+        warn!(error = %err, "Failed to record GitHub issue automation trigger run");
+    }
+}
+
+fn issue_inputs_to_toml(inputs: &GithubIssueRunInputs) -> HashMap<String, toml::Value> {
+    HashMap::from([
+        (
+            "github_issue_url".to_string(),
+            toml::Value::String(inputs.github_issue_url.clone()),
+        ),
+        (
+            "github_issue_number".to_string(),
+            toml::Value::Integer(inputs.github_issue_number as i64),
+        ),
+        (
+            "github_issue_title".to_string(),
+            toml::Value::String(inputs.github_issue_title.clone()),
+        ),
+        (
+            "github_issue_body".to_string(),
+            toml::Value::String(inputs.github_issue_body.clone()),
+        ),
+        (
+            "github_issue_author".to_string(),
+            toml::Value::String(inputs.github_issue_author.clone()),
+        ),
+        (
+            "github_repository".to_string(),
+            toml::Value::String(inputs.github_repository.clone()),
+        ),
+        (
+            "github_default_branch".to_string(),
+            toml::Value::String(inputs.github_default_branch.clone()),
+        ),
+        (
+            "github_trigger_label".to_string(),
+            toml::Value::String(inputs.github_trigger_label.clone()),
+        ),
+        (
+            "github_delivery_id".to_string(),
+            toml::Value::String(inputs.github_delivery_id.clone()),
+        ),
+    ])
+}
+
+async fn github_token(state: &AppState, event: &GithubIssueWebhookEvent) -> anyhow::Result<String> {
+    let (owner, repo) = event
+        .owner_repo()
+        .ok_or_else(|| anyhow::anyhow!("invalid GitHub repository name"))?;
+    let settings = state.server_settings();
+    let credentials = state
+        .github_credentials(&settings.server.integrations.github)
+        .map_err(anyhow::Error::msg)?
+        .ok_or_else(|| anyhow::anyhow!("GitHub credentials are not configured"))?;
+    let client = fabro_http::http_client()?;
+    credentials
+        .resolve_bearer_token(
+            &client,
+            owner,
+            repo,
+            state.github_api_base_url.as_str(),
+            serde_json::json!({ "issues": "write" }),
+        )
+        .await
+}
+
+async fn post_success_comment(
+    state: &AppState,
+    token: Option<&str>,
+    event: &GithubIssueWebhookEvent,
+    automation_name: &str,
+    run_id: RunId,
+    run_url: Option<&str>,
+) {
+    let run_url = run_url.unwrap_or("");
+    post_issue_comment(
+        state,
+        token,
+        event,
+        &format!("Fabro started automation {automation_name} run {run_id}: {run_url}"),
+    )
+    .await;
+}
+
+async fn post_failure_comment(
+    state: &AppState,
+    token: Option<&str>,
+    event: &GithubIssueWebhookEvent,
+    body: String,
+) {
+    post_issue_comment(state, token, event, &body).await;
+}
+
+fn failure_comment(automation_name: &str, reason: &str) -> String {
+    format!("Fabro could not start automation {automation_name}: {reason}")
+}
+
+fn fire_automation_run_failure_reason(err: &FireAutomationRunError) -> &'static str {
+    match err {
+        FireAutomationRunError::Materialize(AutomationRunMaterializeError::WorkflowNotFound(_)) => {
+            "selected workflow missing or unreadable"
+        }
+        FireAutomationRunError::Materialize(AutomationRunMaterializeError::Manifest(_)) => {
+            "selected workflow invalid"
+        }
+        FireAutomationRunError::Materialize(
+            AutomationRunMaterializeError::InvalidTarget(_)
+            | AutomationRunMaterializeError::CloneFailed(_),
+        )
+        | FireAutomationRunError::Create(_) => "run creation failed",
+    }
+}
+
+async fn post_issue_comment(
+    state: &AppState,
+    token: Option<&str>,
+    event: &GithubIssueWebhookEvent,
+    body: &str,
+) {
+    let Some(token) = token else {
+        warn!("GitHub issue automation comment requested but no token is configured");
+        return;
+    };
+    let Some((owner, repo)) = event.owner_repo() else {
+        warn!(repository = %event.repository.full_name, "Cannot post GitHub issue automation comment for invalid repository name");
+        return;
+    };
+    let Ok(client) = fabro_http::http_client() else {
+        warn!("Failed to build HTTP client for GitHub issue automation comment");
+        return;
+    };
+    if let Err(err) = fabro_github::create_issue_comment(
+        &client,
+        token,
+        owner,
+        repo,
+        event.issue.number,
+        body,
+        state.github_api_base_url.as_str(),
+    )
+    .await
+    {
+        warn!(error = %err, issue_number = event.issue.number, repo = %event.repository.full_name, "Failed to post GitHub issue automation comment");
+    }
+}
diff --git a/lib/crates/fabro-server/src/github_issue_events.rs b/lib/crates/fabro-server/src/github_issue_events.rs
new file mode 100644
index 0000000000..cc3706334d
--- /dev/null
+++ b/lib/crates/fabro-server/src/github_issue_events.rs
@@ -0,0 +1,152 @@
+use serde::Deserialize;
+
+#[derive(Debug, Clone, Deserialize)]
+pub(crate) struct GithubIssueWebhookEvent {
+    pub(crate) action:     String,
+    pub(crate) issue:      GithubIssue,
+    pub(crate) label:      Option<GithubLabel>,
+    pub(crate) repository: GithubRepository,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub(crate) struct GithubIssue {
+    pub(crate) number:       u64,
+    pub(crate) title:        String,
+    pub(crate) body:         Option<String>,
+    pub(crate) html_url:     String,
+    pub(crate) user:         GithubSender,
+    #[serde(default)]
+    pub(crate) labels:       Vec<GithubLabel>,
+    pub(crate) pull_request: Option<serde_json::Value>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub(crate) struct GithubLabel {
+    pub(crate) name: String,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub(crate) struct GithubRepository {
+    pub(crate) full_name:      String,
+    pub(crate) default_branch: String,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub(crate) struct GithubSender {
+    pub(crate) login: String,
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub(crate) struct GithubIssueRunInputs {
+    pub(crate) github_issue_url:      String,
+    pub(crate) github_issue_number:   u64,
+    pub(crate) github_issue_title:    String,
+    pub(crate) github_issue_body:     String,
+    pub(crate) github_issue_author:   String,
+    pub(crate) github_repository:     String,
+    pub(crate) github_default_branch: String,
+    pub(crate) github_trigger_label:  String,
+    pub(crate) github_delivery_id:    String,
+}
+
+pub(crate) fn parse_issue_event(body: &[u8]) -> serde_json::Result<GithubIssueWebhookEvent> {
+    serde_json::from_slice(body)
+}
+
+impl GithubIssueWebhookEvent {
+    pub(crate) fn added_label_name(&self) -> Option<&str> {
+        self.label.as_ref().map(|label| label.name.as_str())
+    }
+
+    pub(crate) fn issue_label_names(&self) -> Vec<String> {
+        self.issue
+            .labels
+            .iter()
+            .map(|label| label.name.clone())
+            .collect()
+    }
+
+    pub(crate) fn owner_repo(&self) -> Option<(&str, &str)> {
+        self.repository.full_name.split_once('/')
+    }
+
+    pub(crate) fn is_pull_request(&self) -> bool {
+        self.issue.pull_request.is_some()
+    }
+
+    pub(crate) fn run_inputs(
+        &self,
+        trigger_label: &str,
+        delivery_id: &str,
+    ) -> GithubIssueRunInputs {
+        GithubIssueRunInputs {
+            github_issue_url:      self.issue.html_url.clone(),
+            github_issue_number:   self.issue.number,
+            github_issue_title:    self.issue.title.clone(),
+            github_issue_body:     self.issue.body.clone().unwrap_or_default(),
+            github_issue_author:   self.issue.user.login.clone(),
+            github_repository:     self.repository.full_name.clone(),
+            github_default_branch: self.repository.default_branch.clone(),
+            github_trigger_label:  trigger_label.to_owned(),
+            github_delivery_id:    delivery_id.to_owned(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const ISSUE_LABELED_PAYLOAD: &[u8] = br#"
+{
+  "action": "labeled",
+  "label": { "name": "fabro" },
+  "issue": {
+    "number": 123,
+    "title": "Fix production bug",
+    "body": "The service returns 500.",
+    "html_url": "https://github.com/owner/repo/issues/123",
+    "user": { "login": "alice" },
+    "labels": [
+      { "name": "Bug" },
+      { "name": "fabro" }
+    ]
+  },
+  "repository": {
+    "full_name": "owner/repo",
+    "default_branch": "main",
+    "html_url": "https://github.com/owner/repo"
+  },
+  "sender": { "login": "bob" }
+}
+"#;
+
+    #[test]
+    fn parses_issue_labeled_payload() {
+        let event = parse_issue_event(ISSUE_LABELED_PAYLOAD).expect("payload parses");
+
+        assert_eq!(event.action, "labeled");
+        assert_eq!(event.added_label_name(), Some("fabro"));
+        assert_eq!(event.issue_label_names(), vec!["Bug", "fabro"]);
+        assert_eq!(event.owner_repo(), Some(("owner", "repo")));
+    }
+
+    #[test]
+    fn builds_v1_workflow_inputs() {
+        let event = parse_issue_event(ISSUE_LABELED_PAYLOAD).expect("payload parses");
+
+        let inputs = event.run_inputs("fabro", "delivery-1");
+
+        assert_eq!(inputs, GithubIssueRunInputs {
+            github_issue_url:      "https://github.com/owner/repo/issues/123".to_owned(),
+            github_issue_number:   123,
+            github_issue_title:    "Fix production bug".to_owned(),
+            github_issue_body:     "The service returns 500.".to_owned(),
+            github_issue_author:   "alice".to_owned(),
+            github_repository:     "owner/repo".to_owned(),
+            github_default_branch: "main".to_owned(),
+            github_trigger_label:  "fabro".to_owned(),
+            github_delivery_id:    "delivery-1".to_owned(),
+        });
+    }
+}
diff --git a/lib/crates/fabro-server/src/lib.rs b/lib/crates/fabro-server/src/lib.rs
index 53d5c54518..ce2e3616bf 100644
--- a/lib/crates/fabro-server/src/lib.rs
+++ b/lib/crates/fabro-server/src/lib.rs
@@ -14,6 +14,7 @@ pub mod auth;
     reason = "Automation materializer test hooks and helpers are only referenced by selected targets."
 )]
 mod automation_materializer;
+mod automation_runner;
 mod canonical_host;
 mod canonical_origin;
 pub mod csp;
@@ -25,6 +26,8 @@ pub mod csp;
 mod demo;
 pub mod diagnostics;
 pub mod error;
+mod github_issue_automation_trigger;
+mod github_issue_events;
 pub mod github_webhooks;
 pub mod install;
 pub mod jwt_auth;
diff --git a/lib/crates/fabro-server/src/run_files.rs b/lib/crates/fabro-server/src/run_files.rs
index 1f358821b0..39c8fbbde7 100644
--- a/lib/crates/fabro-server/src/run_files.rs
+++ b/lib/crates/fabro-server/src/run_files.rs
@@ -2387,6 +2387,7 @@ index 1111111..2222222 160000
                 graph_source:     None,
                 workflow_slug:    None,
                 automation:       None,
+                source_context:   None,
                 source_directory: None,
                 labels:           HashMap::default(),
                 provenance:       None,
diff --git a/lib/crates/fabro-server/src/run_manifest.rs b/lib/crates/fabro-server/src/run_manifest.rs
index 4feb22133c..ced698f2df 100644
--- a/lib/crates/fabro-server/src/run_manifest.rs
+++ b/lib/crates/fabro-server/src/run_manifest.rs
@@ -206,6 +206,7 @@ pub(crate) fn create_run_input(
         run_id: prepared.run_id,
         title: prepared.title,
         automation: None,
+        source_context: None,
         git: prepared.git,
         fork_source_ref: None,
         parent_id: prepared.parent_id,
diff --git a/lib/crates/fabro-server/src/serve.rs b/lib/crates/fabro-server/src/serve.rs
index 1178b009b7..dc73c23ab8 100644
--- a/lib/crates/fabro-server/src/serve.rs
+++ b/lib/crates/fabro-server/src/serve.rs
@@ -780,6 +780,8 @@ where
         worker_runtime: None,
         #[cfg(any(test, feature = "test-support"))]
         automation_materializer_override: None,
+        #[cfg(any(test, feature = "test-support"))]
+        automation_run_start_override: None,
     })?;
     let reconciled = reconcile_incomplete_runs_on_startup(&state).await?;
     if reconciled > 0 {
diff --git a/lib/crates/fabro-server/src/server.rs b/lib/crates/fabro-server/src/server.rs
index 7bff4968fe..dcfd823b4f 100644
--- a/lib/crates/fabro-server/src/server.rs
+++ b/lib/crates/fabro-server/src/server.rs
@@ -143,6 +143,8 @@ use crate::automation_materializer::{
     AutomationRunMaterializeError, AutomationRunMaterializeInput, AutomationRunMaterialized,
     AutomationRunMaterializer, GitRepoCache, ProductionAutomationRunMaterializer,
 };
+#[cfg(any(test, feature = "test-support"))]
+use crate::automation_runner::AutomationRunStartOverride;
 use crate::canonical_origin::resolve_canonical_origin;
 use crate::error::ApiError;
 use crate::github_webhooks::{
@@ -169,7 +171,7 @@ use crate::{
 };
 
 mod automation_scheduler;
-mod handler;
+pub(crate) mod handler;
 mod resource_sampler;
 mod session_runtime;
 
@@ -1068,6 +1070,8 @@ pub struct AppState {
     environment_store: Arc<EnvironmentStore>,
     #[cfg(any(test, feature = "test-support"))]
     automation_materializer_override: Option<Arc<dyn AutomationRunMaterializer>>,
+    #[cfg(any(test, feature = "test-support"))]
+    pub(crate) automation_run_start_override: Option<AutomationRunStartOverride>,
     worker_tokens: WorkerTokenKeys,
     started_at: Instant,
     resource_sampler: resource_sampler::ResourceSampler,
@@ -1251,6 +1255,8 @@ pub(crate) struct AppStateConfig {
     pub(crate) worker_runtime: Option<Arc<dyn WorkerRuntime>>,
     #[cfg(any(test, feature = "test-support"))]
     pub(crate) automation_materializer_override: Option<Arc<dyn AutomationRunMaterializer>>,
+    #[cfg(any(test, feature = "test-support"))]
+    pub(crate) automation_run_start_override: Option<AutomationRunStartOverride>,
 }
 
 #[derive(Clone)]
@@ -1782,7 +1788,7 @@ pub fn build_router_with_options(
     }
     let real_router = real_router
         .layer(axum::Extension(github_endpoints))
-        .with_state(state);
+        .with_state(Arc::clone(&state));
 
     let dispatch = service_fn(move |req: axum_extract::Request| {
         let demo = demo_router.clone();
@@ -1840,7 +1846,7 @@ pub fn build_router_with_options(
     let mut router = app_router;
     if let Some(secret) = webhook_secret {
         let secret: Arc<[u8]> = Arc::from(secret.into_bytes().into_boxed_slice());
-        router = github_webhook_routes(secret).merge(router);
+        router = github_webhook_routes(Arc::clone(&state), secret).merge(router);
     }
 
     router
@@ -1949,14 +1955,20 @@ async fn http_log_middleware(mut req: axum_extract::Request, next: Next) -> Resp
     response
 }
 
-fn github_webhook_routes(secret: Arc<[u8]>) -> Router {
+#[derive(Clone)]
+struct GithubWebhookRouteState {
+    secret:    Arc<[u8]>,
+    app_state: Arc<AppState>,
+}
+
+fn github_webhook_routes(app_state: Arc<AppState>, secret: Arc<[u8]>) -> Router {
     Router::new()
         .route(WEBHOOK_ROUTE, post(github_webhook))
-        .with_state(secret)
+        .with_state(GithubWebhookRouteState { secret, app_state })
 }
 
 async fn github_webhook(
-    State(secret): State<Arc<[u8]>>,
+    State(route_state): State<GithubWebhookRouteState>,
     RequestAuth(auth_slot): RequestAuth,
     headers: HeaderMap,
     body: Bytes,
@@ -1964,7 +1976,8 @@ async fn github_webhook(
     let delivery_id = headers
         .get("x-github-delivery")
         .and_then(|value| value.to_str().ok())
-        .unwrap_or("unknown");
+        .unwrap_or("unknown")
+        .to_string();
 
     let Some(signature) = headers
         .get("x-hub-signature-256")
@@ -1975,7 +1988,7 @@ async fn github_webhook(
         return StatusCode::UNAUTHORIZED;
     };
 
-    if !verify_signature(&secret, &body, signature) {
+    if !verify_signature(&route_state.secret, &body, signature) {
         auth_slot.replace(RequestAuthContext::invalid());
         warn!(delivery = %delivery_id, "Webhook HMAC signature mismatch");
         return StatusCode::UNAUTHORIZED;
@@ -1983,7 +1996,7 @@ async fn github_webhook(
 
     auth_slot.replace(RequestAuthContext::authenticated(
         Principal::Webhook {
-            delivery_id: delivery_id.to_string(),
+            delivery_id: delivery_id.clone(),
         },
         None,
     ));
@@ -2010,6 +2023,14 @@ async fn github_webhook(
         );
     }
 
+    crate::github_issue_automation_trigger::handle_github_issue_webhook(
+        Arc::clone(&route_state.app_state),
+        headers,
+        delivery_id,
+        &body,
+    )
+    .await;
+
     StatusCode::OK
 }
 
@@ -2310,6 +2331,8 @@ pub(crate) fn build_app_state(config: AppStateConfig) -> anyhow::Result<Arc<AppS
         worker_runtime,
         #[cfg(any(test, feature = "test-support"))]
         automation_materializer_override,
+        #[cfg(any(test, feature = "test-support"))]
+        automation_run_start_override,
     } = config;
 
     let automation_dir = automation_dir_for_active_config(&active_config_path);
@@ -2440,6 +2463,8 @@ pub(crate) fn build_app_state(config: AppStateConfig) -> anyhow::Result<Arc<AppS
         environment_store,
         #[cfg(any(test, feature = "test-support"))]
         automation_materializer_override,
+        #[cfg(any(test, feature = "test-support"))]
+        automation_run_start_override,
         worker_tokens,
         started_at: Instant::now(),
         resource_sampler: resource_sampler::ResourceSampler::new(),
diff --git a/lib/crates/fabro-server/src/server/automation_scheduler.rs b/lib/crates/fabro-server/src/server/automation_scheduler.rs
index bb5817ccb9..f9f17d56b3 100644
--- a/lib/crates/fabro-server/src/server/automation_scheduler.rs
+++ b/lib/crates/fabro-server/src/server/automation_scheduler.rs
@@ -2,18 +2,17 @@ use std::collections::HashMap;
 use std::sync::Arc;
 use std::time::Duration;
 
-use axum::http::HeaderMap;
 use chrono::{DateTime, Utc};
 use croner::errors::CronError;
 use fabro_automation::{
     Automation, AutomationId, AutomationRevision, AutomationTriggerId, parse_schedule_expression,
 };
-use fabro_types::{AutomationRef, Principal, RunId, SystemActorKind};
+use fabro_types::{Principal, SystemActorKind};
 use tokio::time::sleep;
 use tracing::{Instrument, info, info_span, warn};
 
-use super::{AppState, handler};
-use crate::automation_materializer::AutomationRunMaterializeInput;
+use super::AppState;
+use crate::automation_runner::{FireAutomationRunInput, fire_automation_run};
 
 const AUTOMATION_SCHEDULER_MAX_SLEEP: Duration = Duration::from_secs(30);
 
@@ -216,70 +215,34 @@ async fn fire_scheduled_automation_run(
     trigger_id: AutomationTriggerId,
     due_at: DateTime<Utc>,
 ) {
-    let automation_id = automation.id.clone();
-    let run_id = RunId::new();
-    let materialized = match state
-        .materialize_automation_run(AutomationRunMaterializeInput {
-            automation_id: automation_id.clone(),
-            target: automation.target.clone(),
-            run_id,
-            user_settings_path: state.active_config_path().to_path_buf(),
-            temp_root: state.automation_temp_root(),
-        })
-        .await
+    let actor = Principal::System {
+        system_kind: SystemActorKind::Engine,
+    };
+    let fired = match fire_automation_run(Arc::clone(&state), FireAutomationRunInput {
+        automation,
+        trigger_id,
+        actor: actor.clone(),
+        headers: axum::http::HeaderMap::new(),
+        input_overrides: HashMap::new(),
+        title_override: None,
+        source_context: None,
+    })
+    .await
     {
-        Ok(materialized) => materialized,
+        Ok(fired) => fired,
         Err(err) => {
             warn!(
                 due_at = %due_at,
-                error = %err,
-                "Failed to materialize scheduled automation run",
+                error = ?err,
+                "Failed to create scheduled automation run",
             );
             return;
         }
     };
 
-    let explicit_title_supplied = materialized.manifest.title.is_some();
-    let actor = Principal::System {
-        system_kind: SystemActorKind::Engine,
-    };
-    let automation_ref = AutomationRef {
-        id:         automation_id.to_string(),
-        name:       Some(automation.name.clone()),
-        trigger_id: Some(trigger_id.to_string()),
-    };
-    // `create_run_from_manifest` produces a large future; box it to keep our
-    // stack frame small (matches handler/automations.rs).
-    let response = Box::pin(handler::runs::create_run_from_manifest(
-        Arc::clone(&state),
-        handler::runs::CreateRunFromManifestRequest {
-            manifest: materialized.manifest,
-            submitted_manifest_bytes: materialized.submitted_manifest_bytes,
-            explicit_run_id: Some(run_id),
-            explicit_title_supplied,
-            actor: actor.clone(),
-            headers: HeaderMap::new(),
-            automation: Some(automation_ref),
-        },
-    ))
-    .await;
-
-    let status = response.status();
-    if !status.is_success() {
-        warn!(
-            run_id = %run_id,
-            due_at = %due_at,
-            status = %status,
-            "Failed to create scheduled automation run",
-        );
-        return;
-    }
-
-    if let Err(err) =
-        handler::lifecycle::queue_run_start(state.as_ref(), run_id, false, actor).await
-    {
+    if let Err(err) = fired.start_result {
         warn!(
-            run_id = %run_id,
+            run_id = %fired.created.run_id,
             due_at = %due_at,
             status = %err.status(),
             code = err.code().unwrap_or(""),
@@ -289,7 +252,7 @@ async fn fire_scheduled_automation_run(
     }
 
     info!(
-        run_id = %run_id,
+        run_id = %fired.created.run_id,
         due_at = %due_at,
         "Scheduled automation run queued",
     );
diff --git a/lib/crates/fabro-server/src/server/handler/automations.rs b/lib/crates/fabro-server/src/server/handler/automations.rs
index 39efe6690c..36ce87beca 100644
--- a/lib/crates/fabro-server/src/server/handler/automations.rs
+++ b/lib/crates/fabro-server/src/server/handler/automations.rs
@@ -1,3 +1,4 @@
+use std::collections::HashMap;
 use std::sync::Arc;
 
 use axum::http::HeaderMap;
@@ -6,15 +7,14 @@ use chrono::Utc;
 use fabro_automation::{
     Automation, AutomationDraft, AutomationId, AutomationReplace, AutomationStoreError,
 };
-use fabro_types::{AutomationRef, RunId};
 use serde::Serialize;
 
 use super::super::{
     ApiError, AppState, IntoResponse, Json, PaginationParams, Path, RequiredUser, Response, Router,
     State, StatusCode, get, paginate_items,
 };
-use super::{json_with_etag_response, lifecycle, parse_required_if_match, runs};
-use crate::automation_materializer::AutomationRunMaterializeInput;
+use super::{json_with_etag_response, parse_required_if_match};
+use crate::automation_runner::{FireAutomationRunInput, fire_automation_run};
 use crate::principal_middleware::RequiredRunToolActor;
 
 #[derive(Serialize)]
@@ -136,61 +136,30 @@ async fn create_automation_run(
         )
         .into_response();
     };
-    let api_trigger_id = api_trigger.id.to_string();
-
-    let run_id = RunId::new();
-    let materialized = match state
-        .materialize_automation_run(AutomationRunMaterializeInput {
-            automation_id: automation.id.clone(),
-            target: automation.target.clone(),
-            run_id,
-            user_settings_path: state.active_config_path().to_path_buf(),
-            temp_root: state.automation_temp_root(),
-        })
-        .await
+    let fired = match fire_automation_run(Arc::clone(&state), FireAutomationRunInput {
+        automation: automation.clone(),
+        trigger_id: api_trigger.id.clone(),
+        actor,
+        headers,
+        input_overrides: HashMap::new(),
+        title_override: None,
+        source_context: None,
+    })
+    .await
     {
-        Ok(materialized) => materialized,
-        Err(err) => {
-            return ApiError::new(StatusCode::UNPROCESSABLE_ENTITY, err.to_string())
-                .into_response();
-        }
-    };
-    let explicit_title_supplied = materialized.manifest.title.is_some();
-    let automation_ref = AutomationRef {
-        id:         automation.id.to_string(),
-        name:       Some(automation.name.clone()),
-        trigger_id: Some(api_trigger_id),
+        Ok(fired) => fired,
+        Err(err) => return err.into_api_error().into_response(),
     };
-
-    let response = Box::pin(runs::create_run_from_manifest(
-        Arc::clone(&state),
-        runs::CreateRunFromManifestRequest {
-            manifest: materialized.manifest,
-            submitted_manifest_bytes: materialized.submitted_manifest_bytes,
-            explicit_run_id: Some(run_id),
-            explicit_title_supplied,
-            actor: actor.clone(),
-            headers,
-            automation: Some(automation_ref),
-        },
-    ))
-    .await;
-
-    // An automation's API trigger should both create and start the run; otherwise
-    // the run sits in `Submitted` forever because the scheduler only claims
-    // `Runnable`. Mirror what the UI does for a manual create-then-start flow.
-    if response.status().is_success() {
-        if let Err(err) = lifecycle::queue_run_start(state.as_ref(), run_id, false, actor).await {
-            tracing::warn!(
-                %run_id,
-                automation_id = %automation.id,
-                error = ?err,
-                "Created automation run but failed to start it",
-            );
-        }
+    if let Err(err) = fired.start_result {
+        tracing::warn!(
+            run_id = %fired.created.run_id,
+            automation_id = %automation.id,
+            error = ?err,
+            "Created automation run but failed to start it",
+        );
     }
 
-    response
+    (StatusCode::CREATED, Json(fired.created.summary)).into_response()
 }
 
 async fn create_automation(
diff --git a/lib/crates/fabro-server/src/server/handler/events.rs b/lib/crates/fabro-server/src/server/handler/events.rs
index 180c04bdd1..6d3157f99e 100644
--- a/lib/crates/fabro-server/src/server/handler/events.rs
+++ b/lib/crates/fabro-server/src/server/handler/events.rs
@@ -569,6 +569,7 @@ mod stage_events_tests {
             source_directory: None,
             workflow_slug:    None,
             automation:       None,
+            source_context:   None,
             db_prefix:        None,
             provenance:       None,
             manifest_blob:    None,
diff --git a/lib/crates/fabro-server/src/server/handler/lifecycle.rs b/lib/crates/fabro-server/src/server/handler/lifecycle.rs
index 06beb7c0ba..0012fdf003 100644
--- a/lib/crates/fabro-server/src/server/handler/lifecycle.rs
+++ b/lib/crates/fabro-server/src/server/handler/lifecycle.rs
@@ -67,7 +67,7 @@ async fn start_run(
     }
 }
 
-pub(in crate::server) async fn queue_run_start(
+pub(crate) async fn queue_run_start(
     state: &AppState,
     id: RunId,
     resume: bool,
diff --git a/lib/crates/fabro-server/src/server/handler/mod.rs b/lib/crates/fabro-server/src/server/handler/mod.rs
index 4dd5aa8dc4..726876def6 100644
--- a/lib/crates/fabro-server/src/server/handler/mod.rs
+++ b/lib/crates/fabro-server/src/server/handler/mod.rs
@@ -14,11 +14,11 @@ mod completions;
 mod environments;
 pub(in crate::server) mod events;
 pub(in crate::server) mod graph;
-pub(in crate::server) mod lifecycle;
+pub(crate) mod lifecycle;
 mod models;
 mod pair;
 mod pull_requests;
-pub(in crate::server) mod runs;
+pub(crate) mod runs;
 mod sandbox;
 mod sandboxes;
 mod secrets;
diff --git a/lib/crates/fabro-server/src/server/handler/pair.rs b/lib/crates/fabro-server/src/server/handler/pair.rs
index 7b673fad8a..758f71c496 100644
--- a/lib/crates/fabro-server/src/server/handler/pair.rs
+++ b/lib/crates/fabro-server/src/server/handler/pair.rs
@@ -1023,6 +1023,7 @@ mod tests {
             source_directory: None,
             workflow_slug: None,
             automation: None,
+            source_context: None,
             db_prefix: None,
             provenance: None,
             manifest_blob: None,
diff --git a/lib/crates/fabro-server/src/server/handler/runs.rs b/lib/crates/fabro-server/src/server/handler/runs.rs
index fca9fdc3cb..48f71bfbc3 100644
--- a/lib/crates/fabro-server/src/server/handler/runs.rs
+++ b/lib/crates/fabro-server/src/server/handler/runs.rs
@@ -22,9 +22,9 @@ use fabro_llm::client::Client as LlmClient;
 use fabro_types::settings::ResolveEnvError;
 use fabro_types::{
     AutomationRef, Principal, RunClientProvenance, RunId, RunProvenance, RunServerProvenance,
-    StageContextWindow, StageContextWindowStaleness, StageContextWindowUnavailableReason,
-    StageHandler, StageModelUsage, StageProjection, SystemActorKind, WorkflowSettings,
-    parse_blob_ref,
+    RunSourceContext, StageContextWindow, StageContextWindowStaleness,
+    StageContextWindowUnavailableReason, StageHandler, StageModelUsage, StageProjection,
+    SystemActorKind, WorkflowSettings, parse_blob_ref,
 };
 use fabro_util::version::FABRO_VERSION;
 use fabro_workflow::command_log::{command_log_path, read_json_string_blob, read_log_slice};
@@ -599,7 +599,7 @@ async fn create_run(
         Err(err) => return ApiError::bad_request(err.to_string()).into_response(),
     };
     let explicit_title_supplied = req.title.is_some();
-    Box::pin(create_run_from_manifest(
+    match Box::pin(create_run_from_manifest(
         state,
         CreateRunFromManifestRequest {
             manifest: req,
@@ -609,9 +609,17 @@ async fn create_run(
             actor,
             headers,
             automation: None,
+            source_context: None,
         },
     ))
     .await
+    {
+        Ok(CreatedRunFromManifest { run_id, summary }) => {
+            debug_assert_eq!(summary.id, run_id);
+            (StatusCode::CREATED, Json(summary)).into_response()
+        }
+        Err(err) => err.into_response(),
+    }
 }
 
 pub(crate) struct CreateRunFromManifestRequest {
@@ -622,12 +630,18 @@ pub(crate) struct CreateRunFromManifestRequest {
     pub(crate) actor:                    Principal,
     pub(crate) headers:                  HeaderMap,
     pub(crate) automation:               Option<AutomationRef>,
+    pub(crate) source_context:           Option<RunSourceContext>,
+}
+
+pub(crate) struct CreatedRunFromManifest {
+    pub(crate) run_id:  RunId,
+    pub(crate) summary: fabro_types::Run,
 }
 
 pub(crate) async fn create_run_from_manifest(
     state: Arc<AppState>,
     request: CreateRunFromManifestRequest,
-) -> Response {
+) -> Result<CreatedRunFromManifest, ApiError> {
     let CreateRunFromManifestRequest {
         manifest,
         submitted_manifest_bytes,
@@ -636,6 +650,7 @@ pub(crate) async fn create_run_from_manifest(
         actor,
         headers,
         automation,
+        source_context,
     } = request;
     let manifest_run_defaults = state.manifest_run_defaults();
     let manifest_environment_defaults = state.environment_store().catalog_layer();
@@ -645,11 +660,12 @@ pub(crate) async fn create_run_from_manifest(
         &manifest,
     ) {
         Ok(prepared) => prepared,
-        Err(err) => return ApiError::bad_request(err.to_string()).into_response(),
+        Err(err) => return Err(ApiError::bad_request(err.to_string())),
     };
     if let Err(err) = substitute_run_variables(&state, &mut prepared.settings).await {
-        return ApiError::bad_request(format!("Run config variable interpolation failed: {err}"))
-            .into_response();
+        return Err(ApiError::bad_request(format!(
+            "Run config variable interpolation failed: {err}"
+        )));
     }
     let run_id = explicit_run_id
         .or(prepared.run_id)
@@ -658,14 +674,14 @@ pub(crate) async fn create_run_from_manifest(
     if let Some(error) =
         run_manifest::sandbox_provider_policy_error(&state.server_settings(), provider)
     {
-        return ApiError::bad_request(error).into_response();
+        return Err(ApiError::bad_request(error));
     }
     if let Some(parent_id) = prepared.parent_id {
         if parent_id == run_id {
-            return ApiError::bad_request("A run cannot be its own parent.").into_response();
+            return Err(ApiError::bad_request("A run cannot be its own parent."));
         }
         if let Err(err) = validate_parent_link(&state, run_id, parent_id).await {
-            return err.into_response();
+            return Err(err);
         }
     }
     info!(run_id = %run_id, "Run created");
@@ -696,15 +712,15 @@ pub(crate) async fn create_run_from_manifest(
     create_input.provenance = Some(run_provenance(&headers, &actor));
     create_input.submitted_manifest_bytes = Some(submitted_manifest_bytes);
     create_input.automation = automation;
+    create_input.source_context = source_context;
 
     let storage_root = match resolve_interp_string(&state.server_settings().server.storage.root) {
         Ok(path) => PathBuf::from(path),
         Err(err) => {
-            return ApiError::new(
+            return Err(ApiError::new(
                 StatusCode::INTERNAL_SERVER_ERROR,
                 format!("Failed to resolve server storage root: {err}"),
-            )
-            .into_response();
+            ));
         }
     };
     let created = match Box::pin(operations::create(
@@ -717,14 +733,13 @@ pub(crate) async fn create_run_from_manifest(
     {
         Ok(created) => created,
         Err(WorkflowError::ValidationFailed { .. } | WorkflowError::Parse(_)) => {
-            return ApiError::bad_request("Validation failed").into_response();
+            return Err(ApiError::bad_request("Validation failed"));
         }
         Err(err) => {
-            return ApiError::new(
+            return Err(ApiError::new(
                 StatusCode::INTERNAL_SERVER_ERROR,
                 format!("Failed to persist run state: {err}"),
-            )
-            .into_response();
+            ));
         }
     };
     let created_at = created.run_id.created_at();
@@ -734,10 +749,12 @@ pub(crate) async fn create_run_from_manifest(
         .await
     {
         Ok(Some(summary)) => summary,
-        Ok(None) => return ApiError::not_found("Run not found.").into_response(),
+        Ok(None) => return Err(ApiError::not_found("Run not found.")),
         Err(err) => {
-            return ApiError::new(StatusCode::INTERNAL_SERVER_ERROR, err.to_string())
-                .into_response();
+            return Err(ApiError::new(
+                StatusCode::INTERNAL_SERVER_ERROR,
+                err.to_string(),
+            ));
         }
     };
     let deterministic_title = summary.title.clone();
@@ -780,11 +797,10 @@ pub(crate) async fn create_run_from_manifest(
         }
     }
 
-    (
-        StatusCode::CREATED,
-        Json(state.decorate_run_summary(summary).await),
-    )
-        .into_response()
+    Ok(CreatedRunFromManifest {
+        run_id:  created.run_id,
+        summary: state.decorate_run_summary(summary).await,
+    })
 }
 
 struct GeneratedTitleTask {
diff --git a/lib/crates/fabro-server/src/server/handler/sessions.rs b/lib/crates/fabro-server/src/server/handler/sessions.rs
index bad48c6d4b..875d1affb9 100644
--- a/lib/crates/fabro-server/src/server/handler/sessions.rs
+++ b/lib/crates/fabro-server/src/server/handler/sessions.rs
@@ -1698,6 +1698,7 @@ mod tests {
             graph_source: None,
             workflow_slug: None,
             automation: None,
+            source_context: None,
             source_directory: None,
             labels: HashMap::default(),
             provenance: None,
diff --git a/lib/crates/fabro-server/src/server/tests.rs b/lib/crates/fabro-server/src/server/tests.rs
index 3638847385..11dba4d1ff 100644
--- a/lib/crates/fabro-server/src/server/tests.rs
+++ b/lib/crates/fabro-server/src/server/tests.rs
@@ -10,7 +10,10 @@ use std::sync::{Arc as StdArc, Mutex as StdMutex};
 use axum::body::Body;
 use axum::http::{Method, Request, header};
 use chrono::{Duration as ChronoDuration, Utc};
-use fabro_automation::{AutomationId, AutomationTarget};
+use fabro_automation::{
+    AutomationDraft, AutomationId, AutomationTarget, AutomationTrigger, AutomationTriggerId,
+    GithubIssueTrigger,
+};
 use fabro_config::bind::Bind;
 use fabro_config::{
     EnvironmentLayer, MergeMap, RunLayer, ServerSettingsBuilder, WorkflowSettingsBuilder,
@@ -24,12 +27,12 @@ use fabro_model::catalog::LlmCatalogSettings;
 use fabro_model::{Catalog, ModelRef, ProviderId, ReasoningEffort, Speed};
 use fabro_types::settings::ServerAuthMethod;
 use fabro_types::{
-    AgentBackend, AttrValue, AuthMethod, CommandTermination, FailureCategory, FailureDetail, Graph,
-    InterviewQuestionRecord, Node, Outcome, QuestionType, RunBlobId, RunId, RunSpec,
-    SandboxProviderKind, StageContextWindowBreakdownItem, StageContextWindowCategory,
-    StageContextWindowCountMethod, StageContextWindowProjection, StageContextWindowStaleness,
-    StageContextWindowWarning, StageModelUsage, StageTiming, SuccessReason, SystemActorKind,
-    WorkflowSettings, fixtures,
+    AgentBackend, AttrValue, AuthMethod, CommandTermination, FailureCategory, FailureDetail,
+    GithubIssueRunSource, Graph, InterviewQuestionRecord, Node, Outcome, QuestionType, RunBlobId,
+    RunId, RunSourceContext, RunSpec, SandboxProviderKind, StageContextWindowBreakdownItem,
+    StageContextWindowCategory, StageContextWindowCountMethod, StageContextWindowProjection,
+    StageContextWindowStaleness, StageContextWindowWarning, StageModelUsage, StageTiming,
+    SuccessReason, SystemActorKind, WorkflowSettings, fixtures,
 };
 use fabro_util::check_report::CheckStatus;
 use fabro_workflow::records::CheckpointExt;
@@ -1452,6 +1455,351 @@ async fn github_webhook_accepts_valid_signature_with_wrong_bearer_token() {
     assert_status!(response, StatusCode::OK).await;
 }
 
+fn github_issue_labeled_body(label: &str, labels: &[&str]) -> Vec<u8> {
+    github_issue_body("labeled", label, labels, false)
+}
+
+fn github_issue_unlabeled_body(label: &str, labels: &[&str]) -> Vec<u8> {
+    github_issue_body("unlabeled", label, labels, false)
+}
+
+fn github_pull_request_issue_labeled_body() -> Vec<u8> {
+    github_issue_body("labeled", "fabro", &["Bug", "fabro"], true)
+}
+
+fn github_issue_body(action: &str, label: &str, labels: &[&str], pull_request: bool) -> Vec<u8> {
+    let mut issue = json!({
+        "number": 123,
+        "title": "Fix login redirect",
+        "body": "Users loop back to /login.",
+        "html_url": "https://github.com/owner/repo/issues/123",
+        "user": { "login": "bob" },
+        "labels": labels.iter().map(|label| json!({ "name": label })).collect::<Vec<_>>(),
+    });
+    if pull_request {
+        issue["pull_request"] =
+            json!({ "url": "https://api.github.com/repos/owner/repo/pulls/123" });
+        issue["html_url"] = json!("https://github.com/owner/repo/pull/123");
+    }
+    json!({
+        "action": action,
+        "label": { "name": label },
+        "issue": issue,
+        "repository": {
+            "full_name": "owner/repo",
+            "default_branch": "main",
+            "html_url": "https://github.com/owner/repo"
+        },
+        "sender": { "login": "bob" }
+    })
+    .to_string()
+    .into_bytes()
+}
+
+async fn handle_issue_webhook_direct(state: &Arc<AppState>, delivery_id: &str, body: &[u8]) {
+    let mut headers = axum::http::HeaderMap::new();
+    headers.insert(
+        "x-github-event",
+        axum::http::HeaderValue::from_static("issues"),
+    );
+    headers.insert(
+        "x-github-delivery",
+        axum::http::HeaderValue::from_str(delivery_id).unwrap(),
+    );
+    crate::github_issue_automation_trigger::handle_github_issue_webhook(
+        Arc::clone(state),
+        headers,
+        delivery_id.to_string(),
+        body,
+    )
+    .await;
+}
+
+fn minimal_run_manifest() -> fabro_api::types::RunManifest {
+    serde_json::from_value(json!({
+        "version": 1,
+        "cwd": "/tmp",
+        "target": { "identifier": "workflow.fabro", "path": "workflow.fabro" },
+        "workflows": { "workflow.fabro": { "source": MINIMAL_DOT, "files": {} } },
+    }))
+    .unwrap()
+}
+
+fn test_state_with_successful_automation_materializer()
+-> (Arc<AppState>, TestAutomationRunMaterializer) {
+    let manifest = minimal_run_manifest();
+    let submitted_manifest_bytes = serde_json::to_vec(&manifest).unwrap();
+    let materializer = TestAutomationRunMaterializer::succeed(manifest, submitted_manifest_bytes);
+    let state = TestAppStateBuilder::new()
+        .automation_materializer(materializer.clone())
+        .build();
+    (state, materializer)
+}
+
+fn test_state_with_automation_materializer_and_github_token(
+    materializer: TestAutomationRunMaterializer,
+    github_api_base_url: impl Into<String>,
+    start_error: Option<&str>,
+) -> Arc<AppState> {
+    let settings = ServerSettingsBuilder::from_toml(
+        r#"
+_version = 1
+
+[server.auth]
+methods = ["dev-token"]
+
+[server.web]
+enabled = true
+url = "http://127.0.0.1:32276"
+
+[server.integrations.github]
+strategy = "token"
+"#,
+    )
+    .unwrap();
+    let mut builder = TestAppStateBuilder::new()
+        .runtime_settings(settings, RunLayer::default())
+        .github_api_base_url(github_api_base_url)
+        .automation_materializer(materializer);
+    if let Some(start_error) = start_error {
+        builder = builder.automation_run_start_error(start_error);
+    }
+    let state = builder.build();
+    state
+        .vault
+        .try_write()
+        .unwrap()
+        .set("GITHUB_TOKEN", "ghu_test", SecretType::Token, None)
+        .unwrap();
+    state
+}
+
+fn github_issue_trigger(id: &str, issue_label: Option<&str>) -> AutomationTrigger {
+    AutomationTrigger::GithubIssue(GithubIssueTrigger {
+        id:            AutomationTriggerId::new(id).unwrap(),
+        enabled:       true,
+        trigger_label: "fabro".to_string(),
+        issue_label:   issue_label.map(str::to_string),
+        comment:       false,
+    })
+}
+
+fn github_issue_trigger_with_comment(id: &str, issue_label: Option<&str>) -> AutomationTrigger {
+    AutomationTrigger::GithubIssue(GithubIssueTrigger {
+        id:            AutomationTriggerId::new(id).unwrap(),
+        enabled:       true,
+        trigger_label: "fabro".to_string(),
+        issue_label:   issue_label.map(str::to_string),
+        comment:       true,
+    })
+}
+
+async fn create_github_issue_automation(
+    state: &AppState,
+    id: &str,
+    name: &str,
+    repository: &str,
+    triggers: Vec<AutomationTrigger>,
+) {
+    state
+        .automation_store()
+        .create(AutomationDraft {
+            id: AutomationId::new(id).unwrap(),
+            name: name.to_string(),
+            description: None,
+            target: AutomationTarget {
+                repository:   repository.to_string(),
+                ref_selector: "main".to_string(),
+                workflow:     "workflow.fabro".to_string(),
+            },
+            triggers,
+        })
+        .await
+        .unwrap();
+}
+
+async fn github_issue_automation_runs(state: &AppState) -> Vec<fabro_types::Run> {
+    state
+        .store_ref()
+        .runs()
+        .list(&fabro_store::ListRunsQuery::default())
+        .await
+        .unwrap()
+}
+
+async fn wait_for_github_issue_automation_runs(
+    state: &AppState,
+    expected: usize,
+) -> Vec<fabro_types::Run> {
+    for _ in 0..50 {
+        let runs = github_issue_automation_runs(state).await;
+        if runs.len() >= expected {
+            return runs;
+        }
+        tokio::time::sleep(std::time::Duration::from_millis(20)).await;
+    }
+    panic!("GitHub issue automation runs did not reach {expected}");
+}
+
+#[tokio::test]
+async fn github_issue_labeled_webhook_starts_matching_automation() {
+    let (state, materializer) = test_state_with_successful_automation_materializer();
+    create_github_issue_automation(&state, "issue-bug", "Implement bug", "owner/repo", vec![
+        github_issue_trigger("bug", Some("Bug")),
+    ])
+    .await;
+
+    handle_issue_webhook_direct(
+        &state,
+        "delivery-issue-success",
+        &github_issue_labeled_body("fabro", &["Bug", "fabro"]),
+    )
+    .await;
+
+    let runs = wait_for_github_issue_automation_runs(&state, 1).await;
+    assert_eq!(runs.len(), 1);
+    let captured = materializer.captured_inputs();
+    assert_eq!(
+        captured[0].title_override.as_deref(),
+        Some("Fix login redirect")
+    );
+    assert_eq!(
+        captured[0].input_overrides.get("github_issue_title"),
+        Some(&toml::Value::String("Fix login redirect".to_string()))
+    );
+    assert_eq!(
+        captured[0].input_overrides.get("github_issue_url"),
+        Some(&toml::Value::String(
+            "https://github.com/owner/repo/issues/123".to_string()
+        ))
+    );
+    assert_eq!(runs[0].automation.as_ref().unwrap().id, "issue-bug");
+    assert_eq!(
+        runs[0].automation.as_ref().unwrap().trigger_id.as_deref(),
+        Some("bug")
+    );
+    assert_eq!(
+        runs[0].source_context,
+        Some(RunSourceContext::GithubIssue(GithubIssueRunSource {
+            repository:   "owner/repo".to_string(),
+            issue_number: 123,
+            issue_title:  "Fix login redirect".to_string(),
+            issue_url:    "https://github.com/owner/repo/issues/123".to_string(),
+        }))
+    );
+}
+
+#[tokio::test]
+async fn github_issue_labeled_webhook_acknowledges_before_materialization_finishes() {
+    let manifest = minimal_run_manifest();
+    let submitted_manifest_bytes = serde_json::to_vec(&manifest).unwrap();
+    let materializer = TestAutomationRunMaterializer::succeed_after(
+        manifest,
+        submitted_manifest_bytes,
+        std::time::Duration::from_secs(5),
+    );
+    let state = TestAppStateBuilder::new()
+        .automation_materializer(materializer.clone())
+        .build();
+    create_github_issue_automation(&state, "issue-bug", "Implement bug", "owner/repo", vec![
+        github_issue_trigger("bug", Some("Bug")),
+    ])
+    .await;
+    let body = github_issue_labeled_body("fabro", &["Bug", "fabro"]);
+
+    tokio::time::timeout(
+        std::time::Duration::from_millis(200),
+        handle_issue_webhook_direct(&state, "delivery-issue-slow", &body),
+    )
+    .await
+    .expect("webhook should acknowledge before slow materialization finishes");
+    wait_for_captured_automation_inputs(&materializer, 1).await;
+}
+
+#[tokio::test]
+async fn github_issue_labeled_webhook_ignores_pull_requests() {
+    let (state, _) = test_state_with_successful_automation_materializer();
+    create_github_issue_automation(&state, "issue-bug", "Implement bug", "owner/repo", vec![
+        github_issue_trigger("bug", Some("Bug")),
+    ])
+    .await;
+
+    handle_issue_webhook_direct(
+        &state,
+        "delivery-issue-pr",
+        &github_pull_request_issue_labeled_body(),
+    )
+    .await;
+
+    assert!(github_issue_automation_runs(&state).await.is_empty());
+}
+
+#[tokio::test]
+async fn github_issue_labeled_webhook_dedupes_open_issue_cycle() {
+    let (state, _) = test_state_with_successful_automation_materializer();
+    create_github_issue_automation(&state, "issue-bug", "Implement bug", "owner/repo", vec![
+        github_issue_trigger("bug", Some("Bug")),
+    ])
+    .await;
+    let body = github_issue_labeled_body("fabro", &["Bug", "fabro"]);
+
+    handle_issue_webhook_direct(&state, "delivery-issue-open-1", &body).await;
+    handle_issue_webhook_direct(&state, "delivery-issue-open-2", &body).await;
+
+    wait_for_github_issue_automation_runs(&state, 1).await;
+}
+
+#[tokio::test]
+async fn github_issue_unlabeled_webhook_closes_issue_cycle() {
+    let (state, _) = test_state_with_successful_automation_materializer();
+    create_github_issue_automation(&state, "issue-bug", "Implement bug", "owner/repo", vec![
+        github_issue_trigger("bug", Some("Bug")),
+    ])
+    .await;
+    let labeled = github_issue_labeled_body("fabro", &["Bug", "fabro"]);
+    let unlabeled = github_issue_unlabeled_body("fabro", &["Bug"]);
+
+    handle_issue_webhook_direct(&state, "delivery-issue-open-1", &labeled).await;
+    handle_issue_webhook_direct(&state, "delivery-issue-close", &unlabeled).await;
+    handle_issue_webhook_direct(&state, "delivery-issue-open-2", &labeled).await;
+
+    wait_for_github_issue_automation_runs(&state, 2).await;
+}
+
+#[tokio::test]
+async fn github_issue_start_failure_posts_failure_comment() {
+    let github = MockServer::start();
+    let manifest = minimal_run_manifest();
+    let submitted_manifest_bytes = serde_json::to_vec(&manifest).unwrap();
+    let state = test_state_with_automation_materializer_and_github_token(
+        TestAutomationRunMaterializer::succeed(manifest, submitted_manifest_bytes),
+        github.base_url(),
+        Some("/tmp/secret start failure should not leak"),
+    );
+    create_github_issue_automation(&state, "issue-bug", "Implement bug", "owner/repo", vec![
+        github_issue_trigger_with_comment("bug", Some("Bug")),
+    ])
+    .await;
+    let comment_mock = github.mock(|when, then| {
+        when.method(POST)
+            .path("/repos/owner/repo/issues/123/comments")
+            .header("authorization", "Bearer ghu_test")
+            .body_includes("Fabro could not start automation Implement bug: run start failed");
+        then.status(201)
+            .header("content-type", "application/json")
+            .json_body(json!({ "id": 3 }));
+    });
+
+    handle_issue_webhook_direct(
+        &state,
+        "delivery-issue-start-failure-comment",
+        &github_issue_labeled_body("fabro", &["Bug", "fabro"]),
+    )
+    .await;
+
+    wait_for_mock_hits(&comment_mock, 1).await;
+}
+
 #[tokio::test]
 async fn create_secret_stores_valid_oauth_entries() {
     let state = test_app_state();
@@ -1972,6 +2320,7 @@ fn slack_app_state_with_settings_and_secret_sources(
         worker_control_bus: None,
         worker_runtime: None,
         automation_materializer_override: None,
+        automation_run_start_override: None,
     })
     .expect("slack test app state should build")
 }
@@ -2106,6 +2455,7 @@ fn slack_service_respects_disabled_server_config_even_with_vault_tokens() {
         worker_control_bus: None,
         worker_runtime: None,
         automation_materializer_override: None,
+        automation_run_start_override: None,
     })
     .expect("slack disabled test app state should build");
 
@@ -2467,6 +2817,7 @@ methods = ["dev-token"]
         worker_control_bus: None,
         worker_runtime: None,
         automation_materializer_override: None,
+        automation_run_start_override: None,
     }) else {
         panic!("build_app_state should require SESSION_SECRET")
     };
@@ -2597,6 +2948,7 @@ fn build_test_app_state_with_vault_path(vault_path: &Path) -> anyhow::Result<Arc
         worker_control_bus: None,
         worker_runtime: None,
         automation_materializer_override: None,
+        automation_run_start_override: None,
     })
 }
 
@@ -3397,7 +3749,7 @@ async fn create_run_from_manifest_helper_persists_without_automation_metadata()
     let submitted_manifest_bytes = serde_json::to_vec(&manifest).unwrap();
     let run_id = RunId::new();
 
-    let response = Box::pin(handler::runs::create_run_from_manifest(
+    let created = Box::pin(handler::runs::create_run_from_manifest(
         Arc::clone(&state),
         handler::runs::CreateRunFromManifestRequest {
             manifest,
@@ -3409,13 +3761,15 @@ async fn create_run_from_manifest_helper_persists_without_automation_metadata()
             },
             headers: HeaderMap::new(),
             automation: None,
+            source_context: None,
         },
     ))
-    .await;
+    .await
+    .expect("helper should return a typed created run");
 
-    let body = response_json!(response, StatusCode::CREATED).await;
-    assert_eq!(body["id"], run_id.to_string());
-    assert!(body["automation"].is_null());
+    assert_eq!(created.run_id, run_id);
+    assert_eq!(created.summary.id, run_id);
+    assert!(created.summary.automation.is_none());
     let summary = state
         .store
         .get_cached_summary(&run_id, Utc::now())
@@ -3437,7 +3791,7 @@ async fn create_run_from_manifest_helper_persists_automation_metadata() {
         trigger_id: Some("schedule".to_string()),
     };
 
-    let response = Box::pin(handler::runs::create_run_from_manifest(
+    let created = Box::pin(handler::runs::create_run_from_manifest(
         Arc::clone(&state),
         handler::runs::CreateRunFromManifestRequest {
             manifest,
@@ -3449,19 +3803,30 @@ async fn create_run_from_manifest_helper_persists_automation_metadata() {
             },
             headers: HeaderMap::new(),
             automation: Some(automation.clone()),
+            source_context: None,
         },
     ))
-    .await;
+    .await
+    .expect("helper should return a typed created run");
 
-    let body = response_json!(response, StatusCode::CREATED).await;
-    assert_eq!(body["automation"]["id"], automation.id);
+    assert_eq!(created.run_id, run_id);
+    assert_eq!(
+        created.summary.automation.as_ref().unwrap().id,
+        automation.id
+    );
     assert_eq!(
-        body["automation"]["name"],
-        automation.name.as_deref().unwrap()
+        created.summary.automation.as_ref().unwrap().name.as_deref(),
+        automation.name.as_deref()
     );
     assert_eq!(
-        body["automation"]["trigger_id"],
-        automation.trigger_id.as_deref().unwrap()
+        created
+            .summary
+            .automation
+            .as_ref()
+            .unwrap()
+            .trigger_id
+            .as_deref(),
+        automation.trigger_id.as_deref()
     );
     let summary = state
         .store
@@ -3499,6 +3864,8 @@ async fn fake_automation_materializer_injection_captures_input_and_returns_manif
             run_id,
             user_settings_path: user_settings_path.clone(),
             temp_root: temp_root.clone(),
+            input_overrides: std::collections::HashMap::new(),
+            title_override: None,
         })
         .await
         .expect("fake materializer should succeed");
@@ -3556,6 +3923,19 @@ async fn wait_for_run_title(state: &AppState, run_id: RunId, expected: &str) {
     panic!("run {run_id} title did not become {expected:?}");
 }
 
+async fn wait_for_captured_automation_inputs(
+    materializer: &TestAutomationRunMaterializer,
+    expected: usize,
+) {
+    for _ in 0..50 {
+        if materializer.captured_inputs().len() >= expected {
+            return;
+        }
+        tokio::time::sleep(std::time::Duration::from_millis(20)).await;
+    }
+    panic!("captured automation inputs did not reach {expected}");
+}
+
 async fn wait_for_mock_hits(mock: &httpmock::Mock<'_>, expected: usize) {
     for _ in 0..50 {
         if mock.calls_async().await >= expected {
@@ -4021,6 +4401,7 @@ async fn append_default_run_created(run_store: &fabro_store::RunDatabase, run_id
         source_directory: None,
         workflow_slug: None,
         automation: None,
+        source_context: None,
         db_prefix: None,
         provenance: None,
         manifest_blob: None,
@@ -4075,6 +4456,7 @@ async fn create_slack_notification_run(
         source_directory: None,
         workflow_slug: workflow_slug.map(str::to_string),
         automation: None,
+        source_context: None,
         db_prefix: None,
         provenance: None,
         manifest_blob: None,
@@ -5082,6 +5464,7 @@ async fn list_run_stages_distinguishes_visits() {
             source_directory: None,
             workflow_slug: Some("test".to_string()),
             automation: None,
+            source_context: None,
             db_prefix: None,
             provenance: None,
             manifest_blob: None,
@@ -5950,6 +6333,7 @@ fn create_github_token_app_state_with_env_lookup_and_llm_catalog_settings(
         worker_control_bus: None,
         worker_runtime: None,
         automation_materializer_override: None,
+        automation_run_start_override: None,
     };
     let state = build_app_state(config).expect("test app state should build");
     if let Some(token) = token {
@@ -6137,6 +6521,7 @@ async fn create_completed_run_ready_for_pull_request(
         graph_source: None,
         workflow_slug: Some("test".to_string()),
         automation: None,
+        source_context: None,
         source_directory: Some("/tmp/project".to_string()),
         git: git.clone(),
         labels: HashMap::new(),
@@ -6159,6 +6544,7 @@ async fn create_completed_run_ready_for_pull_request(
             source_directory: run_spec.source_directory.clone(),
             workflow_slug: run_spec.workflow_slug.clone(),
             automation: None,
+            source_context: None,
             db_prefix: None,
             provenance: run_spec.provenance.clone(),
             manifest_blob: None,
@@ -12309,6 +12695,7 @@ async fn create_preserved_local_sandbox_run(state: &Arc<AppState>, run_id: RunId
             source_directory: Some("/tmp/fabro-run".to_string()),
             workflow_slug: Some("test".to_string()),
             automation: None,
+            source_context: None,
             db_prefix: None,
             provenance: None,
             manifest_blob: None,
@@ -13061,6 +13448,7 @@ async fn delete_run_retry_after_missing_provider_resource_removes_metadata() {
             source_directory: Some("/tmp/fabro-run".to_string()),
             workflow_slug: Some("test".to_string()),
             automation: None,
+            source_context: None,
             db_prefix: None,
             provenance: None,
             manifest_blob: None,
diff --git a/lib/crates/fabro-server/src/test_support.rs b/lib/crates/fabro-server/src/test_support.rs
index 7e27318091..dfc6b31d5c 100644
--- a/lib/crates/fabro-server/src/test_support.rs
+++ b/lib/crates/fabro-server/src/test_support.rs
@@ -30,6 +30,7 @@ use ulid::Ulid;
 use crate::auth;
 use crate::automation_materializer::AutomationRunMaterializer;
 pub use crate::automation_materializer::TestAutomationRunMaterializer;
+use crate::automation_runner::AutomationRunStartOverride;
 use crate::jwt_auth::{AuthMode, ConfiguredAuth};
 #[cfg(test)]
 use crate::principal_middleware::{AuthContextSlot, RequestAuthContext};
@@ -74,6 +75,8 @@ pub struct TestAppStateBuilder {
     env_lookup:                EnvLookup,
     llm_catalog_settings:      LlmCatalogSettings,
     automation_materializer:   Option<Arc<dyn AutomationRunMaterializer>>,
+    automation_run_start:      Option<AutomationRunStartOverride>,
+    github_api_base_url:       Option<String>,
     #[cfg(test)]
     worker_runtime:            Option<Arc<dyn WorkerRuntime>>,
 }
@@ -95,6 +98,8 @@ impl Default for TestAppStateBuilder {
             env_lookup:                  default_env_lookup(),
             llm_catalog_settings:        LlmCatalogSettings::default(),
             automation_materializer:     None,
+            automation_run_start:        None,
+            github_api_base_url:         None,
             #[cfg(test)]
             worker_runtime:              None,
         }
@@ -158,6 +163,22 @@ impl TestAppStateBuilder {
         self
     }
 
+    pub fn automation_run_start_error(mut self, message: impl Into<String>) -> Self {
+        let message = message.into();
+        self.automation_run_start = Some(Arc::new(move |_| {
+            Err(crate::error::ApiError::new(
+                axum::http::StatusCode::INTERNAL_SERVER_ERROR,
+                message.clone(),
+            ))
+        }));
+        self
+    }
+
+    pub fn github_api_base_url(mut self, github_api_base_url: impl Into<String>) -> Self {
+        self.github_api_base_url = Some(github_api_base_url.into());
+        self
+    }
+
     #[cfg(test)]
     pub(crate) fn worker_runtime(mut self, worker_runtime: Arc<dyn WorkerRuntime>) -> Self {
         self.worker_runtime = Some(worker_runtime);
@@ -252,7 +273,7 @@ impl TestAppStateBuilder {
             preloaded_vault: None,
             server_secrets: load_test_server_secrets(server_env_path, self.server_secret_env),
             env_lookup: self.env_lookup,
-            github_api_base_url: None,
+            github_api_base_url: self.github_api_base_url,
             active_config_path,
             http_client: Some(
                 fabro_http::test_http_client().expect("test HTTP client should build"),
@@ -264,6 +285,7 @@ impl TestAppStateBuilder {
             #[cfg(test)]
             worker_runtime: self.worker_runtime,
             automation_materializer_override: self.automation_materializer,
+            automation_run_start_override: self.automation_run_start,
         })
     }
 }
diff --git a/lib/crates/fabro-store/Cargo.toml b/lib/crates/fabro-store/Cargo.toml
index 016b55d3d7..8c3baae9c9 100644
--- a/lib/crates/fabro-store/Cargo.toml
+++ b/lib/crates/fabro-store/Cargo.toml
@@ -12,6 +12,7 @@ doctest = false
 workspace = true
 
 [dependencies]
+fabro-automation = { path = "../fabro-automation" }
 fabro-types = { path = "../fabro-types" }
 fabro-util = { path = "../fabro-util" }
 hex.workspace = true
diff --git a/lib/crates/fabro-store/src/lib.rs b/lib/crates/fabro-store/src/lib.rs
index cfc8e1c0c1..11c5175086 100644
--- a/lib/crates/fabro-store/src/lib.rs
+++ b/lib/crates/fabro-store/src/lib.rs
@@ -27,8 +27,11 @@ pub use run_sessions::{
 pub use run_state::RunProjectionReducer;
 pub use serializable_projection::SerializableProjection;
 pub use slate::{
-    AuthCode, AuthCodeStore, Blob, BlobStore, CachedRunProjection, ConsumeOutcome, Database,
-    RefreshToken, RefreshTokenStore, RunCatalogIndex, RunDatabase, Runs, UnreadableRun,
+    AuthCode, AuthCodeStore, AutomationEventSource, AutomationTriggerKind,
+    AutomationTriggerRunContext, AutomationTriggerRunRecord, AutomationTriggerRunStatus,
+    AutomationTriggerRunStore, Blob, BlobStore, CachedRunProjection, ConsumeOutcome, Database,
+    GithubIssueTriggerCycleKey, RefreshToken, RefreshTokenStore, RunCatalogIndex, RunDatabase,
+    Runs, TriggerStartDecision, UnreadableRun,
 };
 pub use types::EventPayload;
 
diff --git a/lib/crates/fabro-store/src/run_state.rs b/lib/crates/fabro-store/src/run_state.rs
index cd6fa06402..c3435fdae9 100644
--- a/lib/crates/fabro-store/src/run_state.rs
+++ b/lib/crates/fabro-store/src/run_state.rs
@@ -792,6 +792,7 @@ fn projection_from_created(event: &EventEnvelope) -> Result<RunProjection> {
         graph_source: props.workflow_source.clone(),
         workflow_slug: props.workflow_slug.clone(),
         automation: props.automation.clone(),
+        source_context: props.source_context.clone(),
         source_directory: props.source_directory.clone(),
         labels,
         provenance: props.provenance.clone(),
@@ -957,6 +958,7 @@ pub(crate) fn build_summary(state: &RunProjection, run_id: &RunId) -> Run {
                 .expect("graph edge count should fit in i64"),
         },
         automation: state.spec.automation.clone(),
+        source_context: state.spec.source_context.clone(),
         repository: Some(RepositoryRef::from_origin_and_source(
             repo_origin_url,
             source_directory.as_deref(),
@@ -1356,6 +1358,7 @@ mod tests {
             graph_source:     Some("digraph test {}".to_string()),
             workflow_slug:    None,
             automation:       None,
+            source_context:   None,
             source_directory: None,
             labels:           HashMap::new(),
             provenance:       None,
@@ -2848,6 +2851,7 @@ mod tests {
             graph_source:     None,
             workflow_slug:    Some("test".to_string()),
             automation:       None,
+            source_context:   None,
             source_directory: Some("/tmp/repo".to_string()),
             git:              None,
             labels:           HashMap::new(),
@@ -2874,6 +2878,7 @@ mod tests {
             graph_source:     None,
             workflow_slug:    Some("release-flow".to_string()),
             automation:       None,
+            source_context:   None,
             source_directory: Some("/tmp/repo".to_string()),
             git:              None,
             labels:           HashMap::new(),
diff --git a/lib/crates/fabro-store/src/slate/automation_trigger_runs.rs b/lib/crates/fabro-store/src/slate/automation_trigger_runs.rs
new file mode 100644
index 0000000000..c256c5645f
--- /dev/null
+++ b/lib/crates/fabro-store/src/slate/automation_trigger_runs.rs
@@ -0,0 +1,682 @@
+use chrono::{DateTime, Utc};
+use fabro_automation::{AutomationId, AutomationTriggerId};
+use fabro_types::RunId;
+use futures::StreamExt as _;
+use object_store::path::Path as ObjectPath;
+use object_store::{Error as ObjectStoreError, PutMode, PutOptions};
+use percent_encoding::{AsciiSet, CONTROLS, utf8_percent_encode};
+use serde::{Deserialize, Serialize};
+
+use super::TriggerStartDecision;
+use crate::{Error, Result};
+
+const ENCODE_SET: &AsciiSet = &CONTROLS
+    .add(b' ')
+    .add(b'!')
+    .add(b'"')
+    .add(b'#')
+    .add(b'$')
+    .add(b'%')
+    .add(b'&')
+    .add(b'\'')
+    .add(b'(')
+    .add(b')')
+    .add(b'*')
+    .add(b'+')
+    .add(b',')
+    .add(b'/')
+    .add(b':')
+    .add(b';')
+    .add(b'<')
+    .add(b'=')
+    .add(b'>')
+    .add(b'?')
+    .add(b'@')
+    .add(b'[')
+    .add(b']')
+    .add(b'`')
+    .add(b'{')
+    .add(b'}');
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct AutomationTriggerRunRecord {
+    pub automation_id: AutomationId,
+    pub trigger_id:    AutomationTriggerId,
+    pub trigger_type:  AutomationTriggerKind,
+    pub event_source:  AutomationEventSource,
+    pub event_id:      String,
+    pub run_id:        Option<RunId>,
+    pub status:        AutomationTriggerRunStatus,
+    pub created_at:    DateTime<Utc>,
+    pub closed_at:     Option<DateTime<Utc>>,
+    pub context:       AutomationTriggerRunContext,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum AutomationTriggerKind {
+    GithubIssue,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum AutomationEventSource {
+    Github,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum AutomationTriggerRunStatus {
+    Started,
+    FailedToStart,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum AutomationTriggerRunContext {
+    GithubIssue {
+        repository:    String,
+        issue_number:  u64,
+        trigger_label: String,
+        issue_label:   Option<String>,
+    },
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct GithubIssueTriggerCycleKey {
+    pub automation_id: AutomationId,
+    pub trigger_id:    AutomationTriggerId,
+    pub repository:    String,
+    pub issue_number:  u64,
+}
+
+#[derive(Clone, Debug)]
+pub struct AutomationTriggerRunStore {
+    pub(super) db: super::Database,
+}
+
+impl AutomationTriggerRunStore {
+    pub async fn decide_github_issue_start(
+        &self,
+        key: &GithubIssueTriggerCycleKey,
+        delivery_id: &str,
+    ) -> Result<TriggerStartDecision> {
+        if !self.create_delivery_marker(delivery_id).await? {
+            return Ok(TriggerStartDecision::DuplicateDelivery);
+        }
+
+        if let Some(existing) = self.read_open_cycle_marker(key).await? {
+            self.delete_delivery_marker(delivery_id).await?;
+            return Ok(TriggerStartDecision::AlreadyOpen {
+                run_id: existing.run_id,
+            });
+        }
+
+        let trigger_cycle = self.next_github_issue_cycle(key).await?;
+        let marker = OpenGithubIssueCycleMarker {
+            automation_id: key.automation_id.clone(),
+            trigger_id: key.trigger_id.clone(),
+            repository: key.repository.clone(),
+            issue_number: key.issue_number,
+            event_id: delivery_id.to_owned(),
+            trigger_cycle,
+            run_id: None,
+            created_at: Utc::now(),
+        };
+        let record = AutomationTriggerRunRecord {
+            automation_id: key.automation_id.clone(),
+            trigger_id:    key.trigger_id.clone(),
+            trigger_type:  AutomationTriggerKind::GithubIssue,
+            event_source:  AutomationEventSource::Github,
+            event_id:      delivery_id.to_owned(),
+            run_id:        None,
+            status:        AutomationTriggerRunStatus::FailedToStart,
+            created_at:    marker.created_at,
+            closed_at:     None,
+            context:       AutomationTriggerRunContext::GithubIssue {
+                repository:    key.repository.clone(),
+                issue_number:  key.issue_number,
+                trigger_label: key.trigger_id.to_string(),
+                issue_label:   None,
+            },
+        };
+        self.write_record(&record).await?;
+
+        match self.create_open_cycle_marker(&marker).await? {
+            CreateMarkerOutcome::Created => Ok(TriggerStartDecision::Start { trigger_cycle }),
+            CreateMarkerOutcome::AlreadyExists(existing) => {
+                self.delete_record(&record).await?;
+                self.delete_delivery_marker(delivery_id).await?;
+                Ok(TriggerStartDecision::AlreadyOpen {
+                    run_id: existing.and_then(|marker| marker.run_id),
+                })
+            }
+        }
+    }
+
+    pub async fn record_started(&self, record: AutomationTriggerRunRecord) -> Result<()> {
+        let AutomationTriggerRunContext::GithubIssue {
+            repository,
+            issue_number,
+            ..
+        } = &record.context;
+        let key = GithubIssueTriggerCycleKey {
+            automation_id: record.automation_id.clone(),
+            trigger_id:    record.trigger_id.clone(),
+            repository:    repository.clone(),
+            issue_number:  *issue_number,
+        };
+        let Some(mut marker) = self.read_open_cycle_marker(&key).await? else {
+            return Err(Error::Other(format!(
+                "automation trigger cycle is not open for automation {} trigger {} GitHub issue {}/{}",
+                record.automation_id, record.trigger_id, repository, issue_number
+            )));
+        };
+        if marker.event_id != record.event_id {
+            return Err(Error::Other(format!(
+                "automation trigger record event {} does not match open cycle event {}",
+                record.event_id, marker.event_id
+            )));
+        }
+        marker.run_id = record.run_id;
+        self.write_open_cycle_marker(&marker).await?;
+        self.write_record(&record).await
+    }
+
+    pub async fn record_failed_to_start(&self, record: AutomationTriggerRunRecord) -> Result<()> {
+        self.write_record(&record).await
+    }
+
+    pub async fn close_github_issue_cycle(&self, key: &GithubIssueTriggerCycleKey) -> Result<bool> {
+        let Some(marker) = self.read_open_cycle_marker(key).await? else {
+            return Ok(false);
+        };
+
+        if let Some(mut record) = self.read_record(&marker).await? {
+            record.closed_at = Some(Utc::now());
+            self.write_record(&record).await?;
+        }
+        self.delete_open_cycle_marker(key).await?;
+        Ok(true)
+    }
+
+    pub async fn records(&self) -> Result<Vec<AutomationTriggerRunRecord>> {
+        self.scan_records().await
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct OpenGithubIssueCycleMarker {
+    automation_id: AutomationId,
+    trigger_id:    AutomationTriggerId,
+    repository:    String,
+    issue_number:  u64,
+    event_id:      String,
+    trigger_cycle: u64,
+    run_id:        Option<RunId>,
+    created_at:    DateTime<Utc>,
+}
+
+enum CreateMarkerOutcome {
+    Created,
+    AlreadyExists(Option<OpenGithubIssueCycleMarker>),
+}
+
+fn encoded(value: &str) -> String {
+    utf8_percent_encode(value, ENCODE_SET).to_string()
+}
+
+fn marker_path(base_prefix: &str, key: &GithubIssueTriggerCycleKey) -> ObjectPath {
+    let base_prefix = base_prefix.trim_end_matches('/');
+    ObjectPath::from(format!(
+        "{base_prefix}/automation_trigger_runs/open/{}/{}/github_issue/{}/{}.json",
+        encoded(key.automation_id.as_str()),
+        encoded(key.trigger_id.as_str()),
+        encoded(&key.repository),
+        key.issue_number,
+    ))
+}
+
+fn delivery_marker_path(base_prefix: &str, delivery_id: &str) -> ObjectPath {
+    let base_prefix = base_prefix.trim_end_matches('/');
+    ObjectPath::from(format!(
+        "{base_prefix}/automation_trigger_runs/deliveries/github/{}.marker",
+        encoded(delivery_id),
+    ))
+}
+
+fn record_path(
+    base_prefix: &str,
+    automation_id: &AutomationId,
+    trigger_id: &AutomationTriggerId,
+    event_id: &str,
+) -> ObjectPath {
+    let base_prefix = base_prefix.trim_end_matches('/');
+    ObjectPath::from(format!(
+        "{base_prefix}/automation_trigger_runs/records/{}/{}/{}.json",
+        encoded(automation_id.as_str()),
+        encoded(trigger_id.as_str()),
+        encoded(event_id),
+    ))
+}
+
+fn records_prefix(base_prefix: &str) -> ObjectPath {
+    let base_prefix = base_prefix.trim_end_matches('/');
+    ObjectPath::from(format!("{base_prefix}/automation_trigger_runs/records"))
+}
+
+impl AutomationTriggerRunStore {
+    async fn create_open_cycle_marker(
+        &self,
+        marker: &OpenGithubIssueCycleMarker,
+    ) -> Result<CreateMarkerOutcome> {
+        let key = GithubIssueTriggerCycleKey {
+            automation_id: marker.automation_id.clone(),
+            trigger_id:    marker.trigger_id.clone(),
+            repository:    marker.repository.clone(),
+            issue_number:  marker.issue_number,
+        };
+        let path = marker_path(&self.db.base_prefix, &key);
+        let bytes = serde_json::to_vec(marker)?;
+        let result = self
+            .db
+            .object_store
+            .put_opts(&path, bytes.into(), PutOptions {
+                mode: PutMode::Create,
+                ..PutOptions::default()
+            })
+            .await;
+
+        match result {
+            Ok(_) => Ok(CreateMarkerOutcome::Created),
+            Err(ObjectStoreError::AlreadyExists { .. }) => Ok(CreateMarkerOutcome::AlreadyExists(
+                self.read_open_cycle_marker(&key).await?,
+            )),
+            Err(err) => Err(Error::Other(format!(
+                "failed to create automation trigger run marker {}: {err}",
+                path
+            ))),
+        }
+    }
+
+    async fn write_open_cycle_marker(&self, marker: &OpenGithubIssueCycleMarker) -> Result<()> {
+        let key = GithubIssueTriggerCycleKey {
+            automation_id: marker.automation_id.clone(),
+            trigger_id:    marker.trigger_id.clone(),
+            repository:    marker.repository.clone(),
+            issue_number:  marker.issue_number,
+        };
+        let path = marker_path(&self.db.base_prefix, &key);
+        let bytes = serde_json::to_vec(marker)?;
+        self.db.object_store.put(&path, bytes.into()).await?;
+        Ok(())
+    }
+
+    async fn read_open_cycle_marker(
+        &self,
+        key: &GithubIssueTriggerCycleKey,
+    ) -> Result<Option<OpenGithubIssueCycleMarker>> {
+        let path = marker_path(&self.db.base_prefix, key);
+        match self.db.object_store.get(&path).await {
+            Ok(result) => {
+                let bytes = result.bytes().await?;
+                Ok(Some(serde_json::from_slice(&bytes)?))
+            }
+            Err(ObjectStoreError::NotFound { .. }) => Ok(None),
+            Err(err) => Err(Error::Other(format!(
+                "failed to read automation trigger run marker {}: {err}",
+                path
+            ))),
+        }
+    }
+
+    async fn delete_open_cycle_marker(&self, key: &GithubIssueTriggerCycleKey) -> Result<()> {
+        let path = marker_path(&self.db.base_prefix, key);
+        match self.db.object_store.delete(&path).await {
+            Ok(()) | Err(ObjectStoreError::NotFound { .. }) => Ok(()),
+            Err(err) => Err(Error::Other(format!(
+                "failed to delete automation trigger run marker {}: {err}",
+                path
+            ))),
+        }
+    }
+
+    async fn create_delivery_marker(&self, delivery_id: &str) -> Result<bool> {
+        let path = delivery_marker_path(&self.db.base_prefix, delivery_id);
+        let result = self
+            .db
+            .object_store
+            .put_opts(&path, bytes::Bytes::from_static(b"1").into(), PutOptions {
+                mode: PutMode::Create,
+                ..PutOptions::default()
+            })
+            .await;
+        match result {
+            Ok(_) => Ok(true),
+            Err(ObjectStoreError::AlreadyExists { .. }) => Ok(false),
+            Err(err) => Err(Error::Other(format!(
+                "failed to create automation trigger delivery marker {}: {err}",
+                path
+            ))),
+        }
+    }
+
+    async fn delete_delivery_marker(&self, delivery_id: &str) -> Result<()> {
+        let path = delivery_marker_path(&self.db.base_prefix, delivery_id);
+        match self.db.object_store.delete(&path).await {
+            Ok(()) | Err(ObjectStoreError::NotFound { .. }) => Ok(()),
+            Err(err) => Err(Error::Other(format!(
+                "failed to delete automation trigger delivery marker {}: {err}",
+                path
+            ))),
+        }
+    }
+
+    async fn write_record(&self, record: &AutomationTriggerRunRecord) -> Result<()> {
+        let path = record_path(
+            &self.db.base_prefix,
+            &record.automation_id,
+            &record.trigger_id,
+            &record.event_id,
+        );
+        let bytes = serde_json::to_vec(record)?;
+        self.db.object_store.put(&path, bytes.into()).await?;
+        Ok(())
+    }
+
+    async fn delete_record(&self, record: &AutomationTriggerRunRecord) -> Result<()> {
+        let path = record_path(
+            &self.db.base_prefix,
+            &record.automation_id,
+            &record.trigger_id,
+            &record.event_id,
+        );
+        match self.db.object_store.delete(&path).await {
+            Ok(()) | Err(ObjectStoreError::NotFound { .. }) => Ok(()),
+            Err(err) => Err(Error::Other(format!(
+                "failed to delete automation trigger run record {}: {err}",
+                path
+            ))),
+        }
+    }
+
+    async fn read_record(
+        &self,
+        marker: &OpenGithubIssueCycleMarker,
+    ) -> Result<Option<AutomationTriggerRunRecord>> {
+        let path = record_path(
+            &self.db.base_prefix,
+            &marker.automation_id,
+            &marker.trigger_id,
+            &marker.event_id,
+        );
+        match self.db.object_store.get(&path).await {
+            Ok(result) => {
+                let bytes = result.bytes().await?;
+                Ok(Some(serde_json::from_slice(&bytes)?))
+            }
+            Err(ObjectStoreError::NotFound { .. }) => Ok(None),
+            Err(err) => Err(Error::Other(format!(
+                "failed to read automation trigger run record {}: {err}",
+                path
+            ))),
+        }
+    }
+
+    async fn scan_records(&self) -> Result<Vec<AutomationTriggerRunRecord>> {
+        let prefix = records_prefix(&self.db.base_prefix);
+        let mut stream = self.db.object_store.list(Some(&prefix));
+        let mut records = Vec::new();
+        while let Some(result) = stream.next().await {
+            let object = result.map_err(|err| {
+                Error::Other(format!(
+                    "failed to list automation trigger run records {}: {err}",
+                    prefix
+                ))
+            })?;
+            let bytes = self
+                .db
+                .object_store
+                .get(&object.location)
+                .await?
+                .bytes()
+                .await?;
+            records.push(serde_json::from_slice(&bytes)?);
+        }
+        records.sort_by(|left: &AutomationTriggerRunRecord, right| {
+            left.automation_id
+                .cmp(&right.automation_id)
+                .then_with(|| left.trigger_id.cmp(&right.trigger_id))
+                .then_with(|| left.event_id.cmp(&right.event_id))
+        });
+        Ok(records)
+    }
+
+    async fn next_github_issue_cycle(&self, key: &GithubIssueTriggerCycleKey) -> Result<u64> {
+        let mut matching_records = 0_u64;
+        for record in self.scan_records().await? {
+            let AutomationTriggerRunContext::GithubIssue {
+                repository,
+                issue_number,
+                ..
+            } = record.context;
+            if record.automation_id == key.automation_id
+                && record.trigger_id == key.trigger_id
+                && repository == key.repository
+                && issue_number == key.issue_number
+            {
+                matching_records += 1;
+            }
+        }
+        Ok(matching_records + 1)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+    use std::time::Duration;
+
+    use fabro_automation::{AutomationId, AutomationTriggerId};
+    use fabro_types::fixtures::RUN_1;
+    use object_store::memory::InMemory;
+
+    use super::*;
+    use crate::slate::Database;
+
+    fn database(object_store: Arc<InMemory>) -> Database {
+        Database::new(
+            object_store,
+            "automation-trigger-run-tests",
+            Duration::from_millis(1),
+            None,
+        )
+    }
+
+    fn key() -> GithubIssueTriggerCycleKey {
+        GithubIssueTriggerCycleKey {
+            automation_id: AutomationId::new("issue-bug").unwrap(),
+            trigger_id:    AutomationTriggerId::new("bug").unwrap(),
+            repository:    "owner/repo".to_string(),
+            issue_number:  123,
+        }
+    }
+
+    fn started_record(
+        key: &GithubIssueTriggerCycleKey,
+        event_id: &str,
+    ) -> AutomationTriggerRunRecord {
+        AutomationTriggerRunRecord {
+            automation_id: key.automation_id.clone(),
+            trigger_id:    key.trigger_id.clone(),
+            trigger_type:  AutomationTriggerKind::GithubIssue,
+            event_source:  AutomationEventSource::Github,
+            event_id:      event_id.to_owned(),
+            run_id:        Some(RUN_1),
+            status:        AutomationTriggerRunStatus::Started,
+            created_at:    Utc::now(),
+            closed_at:     None,
+            context:       AutomationTriggerRunContext::GithubIssue {
+                repository:    key.repository.clone(),
+                issue_number:  key.issue_number,
+                trigger_label: key.trigger_id.to_string(),
+                issue_label:   Some("bug".to_string()),
+            },
+        }
+    }
+
+    #[tokio::test]
+    async fn github_issue_cycle_blocks_until_closed_and_tracks_delivery() {
+        let store = database(Arc::new(InMemory::new()))
+            .automation_trigger_runs()
+            .await
+            .unwrap();
+        let key = key();
+
+        assert_eq!(
+            store
+                .decide_github_issue_start(&key, "delivery-1")
+                .await
+                .unwrap(),
+            TriggerStartDecision::Start { trigger_cycle: 1 }
+        );
+        assert_eq!(
+            store
+                .decide_github_issue_start(&key, "delivery-1")
+                .await
+                .unwrap(),
+            TriggerStartDecision::DuplicateDelivery
+        );
+        assert_eq!(
+            store
+                .decide_github_issue_start(&key, "delivery-2")
+                .await
+                .unwrap(),
+            TriggerStartDecision::AlreadyOpen { run_id: None }
+        );
+        let records = store.records().await.unwrap();
+        assert_eq!(records.len(), 1);
+        assert_eq!(records[0].event_id, "delivery-1");
+        assert!(store.close_github_issue_cycle(&key).await.unwrap());
+        assert_eq!(
+            store
+                .decide_github_issue_start(&key, "delivery-2")
+                .await
+                .unwrap(),
+            TriggerStartDecision::Start { trigger_cycle: 2 }
+        );
+    }
+
+    #[tokio::test]
+    async fn concurrent_same_delivery_is_duplicate_across_store_instances() {
+        let object_store = Arc::new(InMemory::new());
+        let store_a = database(Arc::clone(&object_store))
+            .automation_trigger_runs()
+            .await
+            .unwrap();
+        let store_b = database(object_store)
+            .automation_trigger_runs()
+            .await
+            .unwrap();
+        let key = key();
+
+        let (left, right) = tokio::join!(
+            store_a.decide_github_issue_start(&key, "delivery-1"),
+            store_b.decide_github_issue_start(&key, "delivery-1"),
+        );
+        let mut decisions = vec![left.unwrap(), right.unwrap()];
+        decisions.sort_by_key(|decision| match decision {
+            TriggerStartDecision::Start { .. } => 0,
+            TriggerStartDecision::DuplicateDelivery => 1,
+            TriggerStartDecision::AlreadyOpen { .. } => 2,
+        });
+
+        assert_eq!(decisions, vec![
+            TriggerStartDecision::Start { trigger_cycle: 1 },
+            TriggerStartDecision::DuplicateDelivery,
+        ]);
+    }
+
+    #[tokio::test]
+    async fn record_started_fails_without_prior_open_cycle() {
+        let store = database(Arc::new(InMemory::new()))
+            .automation_trigger_runs()
+            .await
+            .unwrap();
+        let key = key();
+
+        assert!(
+            store
+                .record_started(started_record(&key, "delivery-1"))
+                .await
+                .is_err()
+        );
+        assert!(store.records().await.unwrap().is_empty());
+    }
+
+    #[tokio::test]
+    async fn record_started_fails_after_cycle_is_closed() {
+        let store = database(Arc::new(InMemory::new()))
+            .automation_trigger_runs()
+            .await
+            .unwrap();
+        let key = key();
+
+        assert_eq!(
+            store
+                .decide_github_issue_start(&key, "delivery-1")
+                .await
+                .unwrap(),
+            TriggerStartDecision::Start { trigger_cycle: 1 }
+        );
+        assert!(store.close_github_issue_cycle(&key).await.unwrap());
+
+        assert!(
+            store
+                .record_started(started_record(&key, "delivery-1"))
+                .await
+                .is_err()
+        );
+        let records = store.records().await.unwrap();
+        assert_eq!(records.len(), 1);
+        assert_eq!(records[0].status, AutomationTriggerRunStatus::FailedToStart);
+        assert_eq!(records[0].run_id, None);
+        assert!(records[0].closed_at.is_some());
+    }
+
+    #[tokio::test]
+    async fn encoded_paths_persist_records_across_store_instances() {
+        let object_store = Arc::new(InMemory::new());
+        let store_a = database(Arc::clone(&object_store))
+            .automation_trigger_runs()
+            .await
+            .unwrap();
+        let store_b = database(object_store)
+            .automation_trigger_runs()
+            .await
+            .unwrap();
+        let key = GithubIssueTriggerCycleKey {
+            automation_id: AutomationId::new("issue-bug").unwrap(),
+            trigger_id:    AutomationTriggerId::new("bug_1").unwrap(),
+            repository:    "owner name/repo#1".to_string(),
+            issue_number:  123,
+        };
+
+        assert_eq!(
+            store_a
+                .decide_github_issue_start(&key, "delivery/with spaces#1")
+                .await
+                .unwrap(),
+            TriggerStartDecision::Start { trigger_cycle: 1 }
+        );
+        store_a
+            .record_started(started_record(&key, "delivery/with spaces#1"))
+            .await
+            .unwrap();
+
+        let records = store_b.records().await.unwrap();
+        assert_eq!(records.len(), 1);
+        assert_eq!(records[0].event_id, "delivery/with spaces#1");
+        assert_eq!(records[0].run_id, Some(RUN_1));
+    }
+}
diff --git a/lib/crates/fabro-store/src/slate/mod.rs b/lib/crates/fabro-store/src/slate/mod.rs
index c6406fd8dd..723bc0c4b6 100644
--- a/lib/crates/fabro-store/src/slate/mod.rs
+++ b/lib/crates/fabro-store/src/slate/mod.rs
@@ -1,5 +1,6 @@
 mod auth_codes;
 mod auth_tokens;
+mod automation_trigger_runs;
 mod blob_store;
 mod projection_cache;
 mod run_catalog_index;
@@ -12,6 +13,11 @@ use std::time::Duration;
 
 pub use auth_codes::{AuthCode, AuthCodeStore};
 pub use auth_tokens::{ConsumeOutcome, RefreshToken, RefreshTokenStore};
+pub use automation_trigger_runs::{
+    AutomationEventSource, AutomationTriggerKind, AutomationTriggerRunContext,
+    AutomationTriggerRunRecord, AutomationTriggerRunStatus, AutomationTriggerRunStore,
+    GithubIssueTriggerCycleKey,
+};
 pub use blob_store::{Blob, BlobStore};
 use chrono::{DateTime, Utc};
 use fabro_types::{Run, RunId, SessionId};
@@ -34,6 +40,13 @@ pub struct UnreadableRun {
     pub error:      String,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum TriggerStartDecision {
+    Start { trigger_cycle: u64 },
+    AlreadyOpen { run_id: Option<RunId> },
+    DuplicateDelivery,
+}
+
 #[derive(Debug, Clone, serde::Deserialize, serde::Serialize)]
 struct SessionRunIndexEntry {
     run_id: RunId,
@@ -51,6 +64,7 @@ pub struct Database {
     catalog_index: Arc<OnceCell<Arc<RunCatalogIndex>>>,
     auth_codes: Arc<OnceCell<Arc<AuthCodeStore>>>,
     refresh_tokens: Arc<OnceCell<Arc<RefreshTokenStore>>>,
+    automation_trigger_runs: Arc<OnceCell<Arc<AutomationTriggerRunStore>>>,
     projection_cache: Arc<RunProjectionCache>,
     projection_cache_warmed: Arc<OnceCell<()>>,
 }
@@ -83,6 +97,7 @@ impl Database {
             catalog_index: Arc::new(OnceCell::new()),
             auth_codes: Arc::new(OnceCell::new()),
             refresh_tokens: Arc::new(OnceCell::new()),
+            automation_trigger_runs: Arc::new(OnceCell::new()),
             projection_cache: Arc::new(RunProjectionCache::default()),
             projection_cache_warmed: Arc::new(OnceCell::new()),
         }
@@ -200,6 +215,14 @@ impl Database {
         RunDatabase::open_reader(*run_id, db, Arc::clone(&self.projection_cache)).await
     }
 
+    pub async fn automation_trigger_runs(&self) -> Result<Arc<AutomationTriggerRunStore>> {
+        Ok(self
+            .automation_trigger_runs
+            .get_or_init(|| async { Arc::new(AutomationTriggerRunStore { db: self.clone() }) })
+            .await
+            .clone())
+    }
+
     pub async fn list_runs(&self, query: &ListRunsQuery, now: DateTime<Utc>) -> Result<Vec<Run>> {
         Ok(self
             .list_cached_runs(query, now)
@@ -540,6 +563,7 @@ mod tests {
             graph_source: None,
             workflow_slug: Some("night-sky".to_string()),
             automation: None,
+            source_context: None,
             source_directory: Some(format!("/tmp/{label}")),
             labels: std::collections::HashMap::from([("team".to_string(), "infra".to_string())]),
             provenance: None,
diff --git a/lib/crates/fabro-store/tests/serializable_projection.rs b/lib/crates/fabro-store/tests/serializable_projection.rs
index 6584a36cdb..6f8b8c0a35 100644
--- a/lib/crates/fabro-store/tests/serializable_projection.rs
+++ b/lib/crates/fabro-store/tests/serializable_projection.rs
@@ -20,6 +20,7 @@ fn sample_run_spec() -> RunSpec {
         graph_source:     None,
         workflow_slug:    Some("demo".to_string()),
         automation:       None,
+        source_context:   None,
         source_directory: Some("/tmp/project".to_string()),
         labels:           HashMap::from([("team".to_string(), "platform".to_string())]),
         provenance:       None,
diff --git a/lib/crates/fabro-types/src/lib.rs b/lib/crates/fabro-types/src/lib.rs
index f1a8c8b398..79f6204887 100644
--- a/lib/crates/fabro-types/src/lib.rs
+++ b/lib/crates/fabro-types/src/lib.rs
@@ -93,8 +93,8 @@ pub use pull_request::{
 };
 pub use repository::{RepositoryProvider, RepositoryRef};
 pub use run::{
-    DirtyStatus, ForkSourceRef, GitContext, PreRunPushOutcome, RunClientProvenance, RunProvenance,
-    RunServerProvenance, RunSpec,
+    DirtyStatus, ForkSourceRef, GitContext, GithubIssueRunSource, PreRunPushOutcome,
+    RunClientProvenance, RunProvenance, RunServerProvenance, RunSourceContext, RunSpec,
 };
 pub use run_blob_id::RunBlobId;
 pub use run_event::{
diff --git a/lib/crates/fabro-types/src/run.rs b/lib/crates/fabro-types/src/run.rs
index 2b27d0a067..2834474645 100644
--- a/lib/crates/fabro-types/src/run.rs
+++ b/lib/crates/fabro-types/src/run.rs
@@ -78,6 +78,20 @@ pub struct ForkSourceRef {
     pub checkpoint_sha: String,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum RunSourceContext {
+    GithubIssue(GithubIssueRunSource),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct GithubIssueRunSource {
+    pub repository:   String,
+    pub issue_number: u64,
+    pub issue_title:  String,
+    pub issue_url:    String,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct RunSpec {
     pub run_id:           RunId,
@@ -90,6 +104,8 @@ pub struct RunSpec {
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub automation:       Option<AutomationRef>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub source_context:   Option<RunSourceContext>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
     pub source_directory: Option<String>,
     #[serde(default, skip_serializing_if = "HashMap::is_empty")]
     pub labels:           HashMap<String, String>,
diff --git a/lib/crates/fabro-types/src/run_event/run.rs b/lib/crates/fabro-types/src/run_event/run.rs
index e3023997a1..fe4f2a5c0a 100644
--- a/lib/crates/fabro-types/src/run_event/run.rs
+++ b/lib/crates/fabro-types/src/run_event/run.rs
@@ -6,7 +6,8 @@ use super::{BilledTokenCounts, ExecOutputTail, RunNoticeLevel};
 use crate::status::{BlockedReason, PendingReason, SuccessReason};
 use crate::{
     AutomationRef, DiffSummary, ForkSourceRef, GitContext, Graph, PairId, PairTarget, RunBlobId,
-    RunControlAction, RunFailure, RunId, RunProvenance, RunTiming, WorkflowSettings,
+    RunControlAction, RunFailure, RunId, RunProvenance, RunSourceContext, RunTiming,
+    WorkflowSettings,
 };
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
@@ -29,6 +30,8 @@ pub struct RunCreatedProps {
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub automation:       Option<AutomationRef>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub source_context:   Option<RunSourceContext>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
     pub db_prefix:        Option<String>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub provenance:       Option<RunProvenance>,
diff --git a/lib/crates/fabro-types/src/run_projection.rs b/lib/crates/fabro-types/src/run_projection.rs
index 4b52dcc961..fc5219acae 100644
--- a/lib/crates/fabro-types/src/run_projection.rs
+++ b/lib/crates/fabro-types/src/run_projection.rs
@@ -698,6 +698,7 @@ mod title_tests {
             graph_source: None,
             workflow_slug: None,
             automation: None,
+            source_context: None,
             source_directory: None,
             labels: HashMap::new(),
             provenance: None,
@@ -768,6 +769,7 @@ mod iter_stages_tests {
                 graph_source:     None,
                 workflow_slug:    None,
                 automation:       None,
+                source_context:   None,
                 source_directory: None,
                 labels:           HashMap::default(),
                 provenance:       None,
diff --git a/lib/crates/fabro-types/src/run_summary.rs b/lib/crates/fabro-types/src/run_summary.rs
index fd35dc2a47..9e95e40f9f 100644
--- a/lib/crates/fabro-types/src/run_summary.rs
+++ b/lib/crates/fabro-types/src/run_summary.rs
@@ -5,7 +5,7 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     DiffSummary, InterviewQuestionRecord, Principal, PullRequestLink, RepositoryRef,
-    RunControlAction, RunId, RunSandbox, RunStatus, RunTiming,
+    RunControlAction, RunId, RunSandbox, RunSourceContext, RunStatus, RunTiming,
 };
 
 #[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
@@ -51,6 +51,8 @@ pub struct Run {
     #[serde(default)]
     pub automation:       Option<AutomationRef>,
     #[serde(default)]
+    pub source_context:   Option<RunSourceContext>,
+    #[serde(default)]
     pub repository:       Option<RepositoryRef>,
     #[serde(default)]
     pub created_by:       Option<Principal>,
diff --git a/lib/crates/fabro-types/tests/run_event_serde.rs b/lib/crates/fabro-types/tests/run_event_serde.rs
index 49af80c50e..e0197dbdd6 100644
--- a/lib/crates/fabro-types/tests/run_event_serde.rs
+++ b/lib/crates/fabro-types/tests/run_event_serde.rs
@@ -1,7 +1,10 @@
 use std::collections::BTreeMap;
 
 use fabro_types::graph::Graph;
-use fabro_types::run::{DirtyStatus, ForkSourceRef, GitContext, PreRunPushOutcome};
+use fabro_types::run::{
+    DirtyStatus, ForkSourceRef, GitContext, GithubIssueRunSource, PreRunPushOutcome,
+    RunSourceContext,
+};
 use fabro_types::run_event::run::{RunCreatedProps, RunParentLinkedProps, RunParentUnlinkedProps};
 use fabro_types::run_event::{RunSessionTurnFailedCode, RunSessionTurnFailedProps};
 use fabro_types::settings::InterpString;
@@ -31,6 +34,12 @@ fn run_created_props_round_trip_templated_settings() {
             name:       Some("Nightly".to_string()),
             trigger_id: Some("schedule_1".to_string()),
         }),
+        source_context:   Some(RunSourceContext::GithubIssue(GithubIssueRunSource {
+            repository:   "owner/repo".to_string(),
+            issue_number: 42,
+            issue_title:  "Fix bug".to_string(),
+            issue_url:    "https://github.com/owner/repo/issues/42".to_string(),
+        })),
         db_prefix:        Some("run_".to_string()),
         provenance:       None,
         manifest_blob:    None,
@@ -69,6 +78,14 @@ fn run_created_props_round_trip_templated_settings() {
     assert_eq!(json["parent_id"], fixtures::RUN_2.to_string());
     assert_eq!(json["automation"]["id"], "nightly");
     assert_eq!(json["automation"]["trigger_id"], "schedule_1");
+    assert_eq!(json["source_context"]["type"], "github_issue");
+    assert_eq!(json["source_context"]["repository"], "owner/repo");
+    assert_eq!(json["source_context"]["issue_number"], 42);
+    assert_eq!(json["source_context"]["issue_title"], "Fix bug");
+    assert_eq!(
+        json["source_context"]["issue_url"],
+        "https://github.com/owner/repo/issues/42"
+    );
 
     let round_trip: RunCreatedProps =
         serde_json::from_value(json.clone()).expect("props should deserialize");
@@ -96,6 +113,7 @@ fn run_created_props_omits_web_url_when_absent() {
         source_directory: None,
         workflow_slug:    None,
         automation:       None,
+        source_context:   None,
         db_prefix:        None,
         provenance:       None,
         manifest_blob:    None,
@@ -141,6 +159,7 @@ fn run_created_props_defaults_additive_fields_for_legacy_events() {
         serde_json::from_value(json).expect("legacy props should deserialize");
     assert_eq!(props.retried_from, None);
     assert_eq!(props.automation, None);
+    assert_eq!(props.source_context, None);
 }
 
 #[test]
diff --git a/lib/crates/fabro-types/tests/run_spec_methods.rs b/lib/crates/fabro-types/tests/run_spec_methods.rs
index b05dca05e1..be206016ba 100644
--- a/lib/crates/fabro-types/tests/run_spec_methods.rs
+++ b/lib/crates/fabro-types/tests/run_spec_methods.rs
@@ -25,6 +25,7 @@ fn sample_run_spec() -> RunSpec {
         graph_source: None,
         workflow_slug: Some("demo".to_string()),
         automation: None,
+        source_context: None,
         source_directory: Some("/Users/client/project".to_string()),
         labels: HashMap::from([("team".to_string(), "platform".to_string())]),
         provenance: None,
diff --git a/lib/crates/fabro-types/tests/run_spec_serde.rs b/lib/crates/fabro-types/tests/run_spec_serde.rs
index 89b09ccbd8..94b10df802 100644
--- a/lib/crates/fabro-types/tests/run_spec_serde.rs
+++ b/lib/crates/fabro-types/tests/run_spec_serde.rs
@@ -1,7 +1,10 @@
 use std::collections::HashMap;
 
 use fabro_types::graph::Graph;
-use fabro_types::run::{DirtyStatus, ForkSourceRef, GitContext, PreRunPushOutcome, RunSpec};
+use fabro_types::run::{
+    DirtyStatus, ForkSourceRef, GitContext, GithubIssueRunSource, PreRunPushOutcome,
+    RunSourceContext, RunSpec,
+};
 use fabro_types::settings::InterpString;
 use fabro_types::settings::run::RunGoal;
 use fabro_types::{AutomationRef, WorkflowSettings, fixtures};
@@ -25,6 +28,12 @@ fn run_spec_round_trips_templated_settings() {
             name:       Some("Nightly".to_string()),
             trigger_id: Some("schedule_1".to_string()),
         }),
+        source_context:   Some(RunSourceContext::GithubIssue(GithubIssueRunSource {
+            repository:   "owner/repo".to_string(),
+            issue_number: 42,
+            issue_title:  "Fix bug".to_string(),
+            issue_url:    "https://github.com/owner/repo/issues/42".to_string(),
+        })),
         source_directory: Some("/Users/client/project".to_string()),
         labels:           HashMap::from([("team".to_string(), "platform".to_string())]),
         provenance:       None,
@@ -61,6 +70,14 @@ fn run_spec_round_trips_templated_settings() {
     assert_eq!(json["fork_source_ref"]["checkpoint_sha"], "def456");
     assert_eq!(json["automation"]["id"], "nightly");
     assert_eq!(json["automation"]["trigger_id"], "schedule_1");
+    assert_eq!(json["source_context"]["type"], "github_issue");
+    assert_eq!(json["source_context"]["repository"], "owner/repo");
+    assert_eq!(json["source_context"]["issue_number"], 42);
+    assert_eq!(json["source_context"]["issue_title"], "Fix bug");
+    assert_eq!(
+        json["source_context"]["issue_url"],
+        "https://github.com/owner/repo/issues/42"
+    );
     let round_trip: RunSpec =
         serde_json::from_value(json.clone()).expect("record should deserialize");
 
@@ -86,4 +103,5 @@ fn run_spec_defaults_automation_for_legacy_specs() {
     let record: RunSpec = serde_json::from_value(json).expect("legacy spec should deserialize");
 
     assert_eq!(record.automation, None);
+    assert_eq!(record.source_context, None);
 }
diff --git a/lib/crates/fabro-workflow/src/event/convert.rs b/lib/crates/fabro-workflow/src/event/convert.rs
index 4c1f912288..db35c917c3 100644
--- a/lib/crates/fabro-workflow/src/event/convert.rs
+++ b/lib/crates/fabro-workflow/src/event/convert.rs
@@ -35,6 +35,7 @@ fn event_body_from_event(event: &Event) -> EventBody {
             source_directory,
             workflow_slug,
             automation,
+            source_context,
             db_prefix,
             provenance,
             manifest_blob,
@@ -56,6 +57,7 @@ fn event_body_from_event(event: &Event) -> EventBody {
             source_directory: source_directory.clone(),
             workflow_slug:    workflow_slug.clone(),
             automation:       automation.clone(),
+            source_context:   source_context.clone(),
             db_prefix:        db_prefix.clone(),
             provenance:       provenance.clone(),
             manifest_blob:    *manifest_blob,
diff --git a/lib/crates/fabro-workflow/src/event/events.rs b/lib/crates/fabro-workflow/src/event/events.rs
index 8868688049..8c826e2a69 100644
--- a/lib/crates/fabro-workflow/src/event/events.rs
+++ b/lib/crates/fabro-workflow/src/event/events.rs
@@ -5,8 +5,8 @@ use ::fabro_types::{
     FailureReason, ForkSourceRef, GitContext, PairId, PairMessageId, PairSystemMessageKind,
     PairTarget, ParallelBranchId, PendingReason, PermissionLevel, Principal, PullRequestLink,
     RunBlobId, RunFailure, RunId, RunNoticeLevel, RunPairEndedReason, RunPairFailedReason,
-    RunProvenance, RunRunnableSource, RunTiming, SandboxProviderKind, StageId, StageTiming,
-    SuccessReason, run_event as fabro_types,
+    RunProvenance, RunRunnableSource, RunSourceContext, RunTiming, SandboxProviderKind, StageId,
+    StageTiming, SuccessReason, run_event as fabro_types,
 };
 use fabro_agent::{AgentEvent, SandboxEvent};
 use fabro_model::{ReasoningEffort, Speed};
@@ -40,6 +40,8 @@ pub enum Event {
         #[serde(default, skip_serializing_if = "Option::is_none")]
         automation:       Option<AutomationRef>,
         #[serde(default, skip_serializing_if = "Option::is_none")]
+        source_context:   Option<RunSourceContext>,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
         db_prefix:        Option<String>,
         #[serde(default, skip_serializing_if = "Option::is_none")]
         provenance:       Option<RunProvenance>,
diff --git a/lib/crates/fabro-workflow/src/operations/create.rs b/lib/crates/fabro-workflow/src/operations/create.rs
index 8bf16d1157..1b48a4800d 100644
--- a/lib/crates/fabro-workflow/src/operations/create.rs
+++ b/lib/crates/fabro-workflow/src/operations/create.rs
@@ -13,7 +13,8 @@ use fabro_graphviz::graph::{AttrValue, Graph};
 use fabro_model::{Catalog, ProviderId};
 use fabro_store::Database;
 use fabro_types::{
-    AutomationRef, ForkSourceRef, GitContext, ManifestPath, RunId, RunProvenance, WorkflowSettings,
+    AutomationRef, ForkSourceRef, GitContext, ManifestPath, RunId, RunProvenance, RunSourceContext,
+    WorkflowSettings,
 };
 use fabro_util::json::normalize_json_value;
 use tokio::task::spawn_blocking;
@@ -42,6 +43,7 @@ pub struct CreateRunInput {
     pub run_id: Option<RunId>,
     pub title: Option<String>,
     pub automation: Option<AutomationRef>,
+    pub source_context: Option<RunSourceContext>,
     pub git: Option<GitContext>,
     pub fork_source_ref: Option<ForkSourceRef>,
     pub parent_id: Option<RunId>,
@@ -70,6 +72,7 @@ struct PersistCreateOptions {
     labels:               HashMap<String, String>,
     source_directory:     Option<String>,
     automation:           Option<AutomationRef>,
+    source_context:       Option<RunSourceContext>,
     git:                  Option<GitContext>,
     fork_source_ref:      Option<ForkSourceRef>,
     provenance:           Option<RunProvenance>,
@@ -105,6 +108,7 @@ pub async fn create(
         run_id,
         title,
         automation,
+        source_context,
         git,
         fork_source_ref,
         parent_id,
@@ -136,6 +140,7 @@ pub async fn create(
         .dot_path
         .as_ref()
         .map(|path| path.display().to_string());
+    let event_source_context = source_context.clone();
     let persisted = spawn_blocking(move || {
         create_from_source(
             &raw_source,
@@ -148,6 +153,7 @@ pub async fn create(
                 labels,
                 source_directory,
                 automation,
+                source_context,
                 git,
                 fork_source_ref,
                 provenance,
@@ -174,6 +180,7 @@ pub async fn create(
         submitted_manifest_bytes.as_deref(),
         accepted_definition.as_ref(),
         title,
+        event_source_context,
         parent_id,
         web_url,
     )
@@ -195,6 +202,7 @@ async fn persist_created_run(
     submitted_manifest_bytes: Option<&[u8]>,
     accepted_definition: Option<&RunDefinition>,
     explicit_title: Option<String>,
+    source_context: Option<RunSourceContext>,
     parent_id: Option<RunId>,
     web_url: Option<String>,
 ) -> Result<(), Error> {
@@ -245,6 +253,7 @@ async fn persist_created_run(
             source_directory: record.source_directory.clone(),
             workflow_slug: record.workflow_slug.clone(),
             automation: record.automation.clone(),
+            source_context: source_context.or_else(|| record.source_context.clone()),
             db_prefix: None,
             provenance: record.provenance.clone(),
             manifest_blob,
@@ -362,6 +371,7 @@ fn persist_validated(
         labels,
         source_directory,
         automation,
+        source_context,
         git,
         fork_source_ref,
         provenance,
@@ -386,6 +396,7 @@ fn persist_validated(
         graph_source: Some(validated.source().to_string()),
         workflow_slug,
         automation,
+        source_context,
         source_directory,
         labels,
         provenance,
@@ -1112,6 +1123,7 @@ mod tests {
                 run_id: None,
                 title: None,
                 automation: None,
+                source_context: None,
                 git: None,
                 fork_source_ref: None,
                 parent_id: None,
@@ -1174,6 +1186,7 @@ mod tests {
                 run_id: Some(fixtures::RUN_1),
                 title: None,
                 automation: None,
+                source_context: None,
                 git: Some(fabro_types::GitContext {
                     origin_url:   String::new(),
                     branch:       "main".to_string(),
@@ -1292,6 +1305,7 @@ mod tests {
                 run_id: Some(fixtures::RUN_2),
                 title: None,
                 automation: None,
+                source_context: None,
                 git: None,
                 fork_source_ref: None,
                 parent_id: None,
@@ -1332,6 +1346,7 @@ mod tests {
                 run_id: Some(fixtures::RUN_2),
                 title: None,
                 automation: None,
+                source_context: None,
                 git: Some(fabro_types::GitContext {
                     origin_url:   "https://github.com/acme/widgets".to_string(),
                     branch:       String::new(),
@@ -1411,6 +1426,7 @@ mod tests {
                 run_id: Some(fixtures::RUN_3),
                 title: None,
                 automation: Some(automation.clone()),
+                source_context: None,
                 git: None,
                 fork_source_ref: None,
                 parent_id: None,
@@ -1464,6 +1480,7 @@ mod tests {
                 run_id: Some(fixtures::RUN_64),
                 title: None,
                 automation: None,
+                source_context: None,
                 git: None,
                 fork_source_ref: None,
                 parent_id: None,
diff --git a/lib/crates/fabro-workflow/src/operations/fork.rs b/lib/crates/fabro-workflow/src/operations/fork.rs
index 2bf7e144fc..6a9c2e3bb4 100644
--- a/lib/crates/fabro-workflow/src/operations/fork.rs
+++ b/lib/crates/fabro-workflow/src/operations/fork.rs
@@ -162,6 +162,7 @@ async fn persist_forked_run(
         source_directory: spec.source_directory.clone(),
         workflow_slug:    spec.workflow_slug.clone(),
         automation:       spec.automation.clone(),
+        source_context:   spec.source_context.clone(),
         db_prefix:        None,
         provenance:       spec.provenance.clone(),
         manifest_blob:    spec.manifest_blob,
diff --git a/lib/crates/fabro-workflow/src/operations/retry.rs b/lib/crates/fabro-workflow/src/operations/retry.rs
index be7793d3e8..ea6f8fc77e 100644
--- a/lib/crates/fabro-workflow/src/operations/retry.rs
+++ b/lib/crates/fabro-workflow/src/operations/retry.rs
@@ -49,6 +49,7 @@ pub async fn retry_run(
         graph_source,
         workflow_slug,
         automation,
+        source_context,
         source_directory,
         labels,
         provenance: _,
@@ -78,6 +79,7 @@ pub async fn retry_run(
         source_directory,
         workflow_slug,
         automation,
+        source_context,
         db_prefix: None,
         provenance: input.provenance.clone(),
         manifest_blob,
diff --git a/lib/crates/fabro-workflow/src/test_support.rs b/lib/crates/fabro-workflow/src/test_support.rs
index e72a0ee1bd..9016ab0622 100644
--- a/lib/crates/fabro-workflow/src/test_support.rs
+++ b/lib/crates/fabro-workflow/src/test_support.rs
@@ -174,6 +174,7 @@ async fn initialized(
         source_directory: Some(sandbox.working_directory().to_string()),
         workflow_slug:    run_options.workflow_slug.clone(),
         automation:       None,
+        source_context:   None,
         db_prefix:        None,
         provenance:       None,
         manifest_blob:    None,
diff --git a/lib/packages/fabro-api-client/src/.openapi-generator/FILES b/lib/packages/fabro-api-client/src/.openapi-generator/FILES
index 5e97116d98..a7140ecb14 100644
--- a/lib/packages/fabro-api-client/src/.openapi-generator/FILES
+++ b/lib/packages/fabro-api-client/src/.openapi-generator/FILES
@@ -57,6 +57,7 @@ models/auth-session-user.ts
 models/auth-session.ts
 models/auth-sessions-response.ts
 models/automation-api-trigger.ts
+models/automation-github-issue-trigger.ts
 models/automation-list-meta.ts
 models/automation-list-response.ts
 models/automation-ref.ts
@@ -153,6 +154,7 @@ models/git-author-settings.ts
 models/git-context.ts
 models/github-integration-settings.ts
 models/github-integration-strategy.ts
+models/github-issue-run-source.ts
 models/health-response.ts
 models/history-entry.ts
 models/hook-definition.ts
diff --git a/lib/packages/fabro-api-client/src/models/automation-github-issue-trigger.ts b/lib/packages/fabro-api-client/src/models/automation-github-issue-trigger.ts
new file mode 100644
index 0000000000..eabab99d3a
--- /dev/null
+++ b/lib/packages/fabro-api-client/src/models/automation-github-issue-trigger.ts
@@ -0,0 +1,33 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Fabro Run API
+ * HTTP API for managing Fabro workflow run executions.
+ *
+ * The version of the OpenAPI document: 0.1.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+
+
+/**
+ * GitHub issue label trigger. Fires on issues.labeled and resets on issues.unlabeled for the trigger label.
+ */
+export interface AutomationGithubIssueTrigger {
+    'id': string;
+    'type': AutomationGithubIssueTriggerTypeEnum;
+    'enabled': boolean;
+    'trigger_label': string;
+    'issue_label'?: string | null;
+    'comment'?: boolean;
+}
+
+export const AutomationGithubIssueTriggerTypeEnum = {
+    GITHUB_ISSUE: 'github_issue'
+} as const;
+
+export type AutomationGithubIssueTriggerTypeEnum = typeof AutomationGithubIssueTriggerTypeEnum[keyof typeof AutomationGithubIssueTriggerTypeEnum];
diff --git a/lib/packages/fabro-api-client/src/models/automation-trigger.ts b/lib/packages/fabro-api-client/src/models/automation-trigger.ts
index 30e73dc816..e3459108a7 100644
--- a/lib/packages/fabro-api-client/src/models/automation-trigger.ts
+++ b/lib/packages/fabro-api-client/src/models/automation-trigger.ts
@@ -18,10 +18,13 @@
 import type { AutomationApiTrigger } from './automation-api-trigger';
 // May contain unused imports in some cases
 // @ts-ignore
+import type { AutomationGithubIssueTrigger } from './automation-github-issue-trigger';
+// May contain unused imports in some cases
+// @ts-ignore
 import type { AutomationScheduleTrigger } from './automation-schedule-trigger';
 
 /**
  * @type AutomationTrigger
  * Automation trigger configuration. Unknown `type` discriminator values are reported by handlers as domain validation errors with HTTP 422.
  */
-export type AutomationTrigger = { type: 'api' } & AutomationApiTrigger | { type: 'schedule' } & AutomationScheduleTrigger;
+export type AutomationTrigger = { type: 'api' } & AutomationApiTrigger | { type: 'github_issue' } & AutomationGithubIssueTrigger | { type: 'schedule' } & AutomationScheduleTrigger;
diff --git a/lib/packages/fabro-api-client/src/models/github-issue-run-source.ts b/lib/packages/fabro-api-client/src/models/github-issue-run-source.ts
new file mode 100644
index 0000000000..862aeb34f8
--- /dev/null
+++ b/lib/packages/fabro-api-client/src/models/github-issue-run-source.ts
@@ -0,0 +1,29 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Fabro Run API
+ * HTTP API for managing Fabro workflow run executions.
+ *
+ * The version of the OpenAPI document: 0.1.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+
+
+export interface GithubIssueRunSource {
+    'type': GithubIssueRunSourceTypeEnum;
+    'repository': string;
+    'issue_number': number;
+    'issue_title': string;
+    'issue_url': string;
+}
+
+export const GithubIssueRunSourceTypeEnum = {
+    GITHUB_ISSUE: 'github_issue'
+} as const;
+
+export type GithubIssueRunSourceTypeEnum = typeof GithubIssueRunSourceTypeEnum[keyof typeof GithubIssueRunSourceTypeEnum];
diff --git a/lib/packages/fabro-api-client/src/models/index.ts b/lib/packages/fabro-api-client/src/models/index.ts
index 87b9c189cd..c452accb10 100644
--- a/lib/packages/fabro-api-client/src/models/index.ts
+++ b/lib/packages/fabro-api-client/src/models/index.ts
@@ -31,6 +31,7 @@ export * from './auth-session-user';
 export * from './auth-sessions-response';
 export * from './automation';
 export * from './automation-api-trigger';
+export * from './automation-github-issue-trigger';
 export * from './automation-list-meta';
 export * from './automation-list-response';
 export * from './automation-ref';
@@ -126,6 +127,7 @@ export * from './git-author-settings';
 export * from './git-context';
 export * from './github-integration-settings';
 export * from './github-integration-strategy';
+export * from './github-issue-run-source';
 export * from './health-response';
 export * from './history-entry';
 export * from './hook-definition';
diff --git a/lib/packages/fabro-api-client/src/models/run-spec.ts b/lib/packages/fabro-api-client/src/models/run-spec.ts
index f1e5adab6c..6a9e3b5b13 100644
--- a/lib/packages/fabro-api-client/src/models/run-spec.ts
+++ b/lib/packages/fabro-api-client/src/models/run-spec.ts
@@ -24,6 +24,9 @@ import type { ForkSourceRef } from './fork-source-ref';
 import type { GitContext } from './git-context';
 // May contain unused imports in some cases
 // @ts-ignore
+import type { GithubIssueRunSource } from './github-issue-run-source';
+// May contain unused imports in some cases
+// @ts-ignore
 import type { RunProvenance } from './run-provenance';
 // May contain unused imports in some cases
 // @ts-ignore
@@ -39,6 +42,7 @@ export interface RunSpec {
     'graph_source'?: string | null;
     'workflow_slug'?: string | null;
     'automation'?: AutomationRef | null;
+    'source_context'?: GithubIssueRunSource | null;
     'source_directory'?: string | null;
     'labels'?: { [key: string]: string; };
     'provenance'?: RunProvenance | null;
diff --git a/lib/packages/fabro-api-client/src/models/run.ts b/lib/packages/fabro-api-client/src/models/run.ts
index 1ed6c6c261..779d64faa5 100644
--- a/lib/packages/fabro-api-client/src/models/run.ts
+++ b/lib/packages/fabro-api-client/src/models/run.ts
@@ -24,6 +24,9 @@ import type { AutomationRef } from './automation-ref';
 import type { DiffSummary } from './diff-summary';
 // May contain unused imports in some cases
 // @ts-ignore
+import type { GithubIssueRunSource } from './github-issue-run-source';
+// May contain unused imports in some cases
+// @ts-ignore
 import type { Principal } from './principal';
 // May contain unused imports in some cases
 // @ts-ignore
@@ -82,6 +85,7 @@ export interface Run {
     'goal': string;
     'workflow': WorkflowRef;
     'automation': AutomationRef | null;
+    'source_context'?: GithubIssueRunSource | null;
     'repository': RepositoryRef | null;
     'created_by': Principal | null;
     'origin': RunOrigin;