create-interview-cockpit 0.23.0 → 0.23.2

package/template/client/src/components/Sidebar.tsx

@@ -1,6 +1,7 @@
 import { useState, useEffect, useRef, Fragment } from "react";
 import { useStore } from "../store";
 import type { Question } from "../types";
+import type { DriveFolder } from "../api";
 import * as api from "../api";
 import FileAttachments from "./FileAttachments";
 import WorkspaceSwitcher from "./WorkspaceSwitcher";
@@ -116,6 +117,8 @@ export default function Sidebar() {
     driveRootFolders,
     loadingDriveFolders,
     fetchDriveRootFolders,
+    fetchDriveSubfolders,
+    createDriveSubfolder,
     selectDriveSubfolder,
     clearDriveSubfolder,
     syncWorkspace,
@@ -214,6 +217,10 @@ export default function Sidebar() {
   const isAtDriveFolderRoot = isDriveWs && !currentSubFolder;
   const canSyncDriveFolder =
     !!activeWs?.driveConfig?.folderId && !isAtDriveFolderRoot;
+  const canPushLocalDrive =
+    activeWs?.type === "local" && !!activeWs.driveConfig?.folderId;
+  const canPushDriveDestination =
+    !!activeWs?.driveConfig?.folderId && (!isDriveWs || !!currentSubFolder);
   const driveSyncTargetName =
     currentSubFolder?.name ?? activeWs?.driveConfig?.folderName ?? "Drive";
   const [navigating, setNavigating] = useState(false);
@@ -224,6 +231,15 @@ export default function Sidebar() {
   const [topicDriveStatus, setTopicDriveStatus] = useState<
     Record<string, string>
   >({});
+  const [pushPicker, setPushPicker] = useState<{
+    mode: "workspace" | "topic";
+    topicId?: string;
+    folders: DriveFolder[];
+    loading: boolean;
+  } | null>(null);
+  const [pushPickerNewFolderName, setPushPickerNewFolderName] = useState("");
+  const [pushPickerCreatingFolder, setPushPickerCreatingFolder] =
+    useState(false);
   const [wsFilesExpanded, setWsFilesExpanded] = useState(true);
   const [driveFileSyncStatus, setDriveFileSyncStatus] = useState<string | null>(
     null,
@@ -277,15 +293,12 @@ export default function Sidebar() {
     }
   };
 
-  const handlePushToDrive = async () => {
+  const pushWorkspaceToDrive = async (targetFolderId: string) => {
     if (!activeWorkspaceId || !activeWs?.driveConfig?.folderId) return;
     setPushing(true);
     setDriveFileSyncStatus(null);
     try {
-      const result = await exportWorkspace(
-        activeWorkspaceId,
-        activeWs.driveConfig.subFolderId,
-      );
+      const result = await exportWorkspace(activeWorkspaceId, targetFolderId);
       if ("needsAuth" in result && result.needsAuth) {
         window.location.href = result.authUrl;
         return;
@@ -302,58 +315,100 @@ export default function Sidebar() {
     }
   };
 
-  const setTopicStatus = (topicId: string, value: string) => {
-    setTopicDriveStatus((prev) => ({ ...prev, [topicId]: value }));
-  };
-
-  const handlePullTopicFromDrive = async (topicId: string) => {
+  const pushTopicToDrive = async (topicId: string, targetFolderId: string) => {
     if (!activeWorkspaceId || !activeWs?.driveConfig?.folderId) return;
-    setTopicSyncingId(topicId);
-    setTopicStatus(topicId, "Pulling topic from Drive…");
+    setTopicPushingId(topicId);
+    setTopicStatus(topicId, "Pushing topic to Drive…");
     try {
-      const result = await syncTopic(activeWorkspaceId, topicId);
+      const result = await exportTopic(activeWorkspaceId, topicId, targetFolderId);
       if ("needsAuth" in result && result.needsAuth) {
         window.location.href = result.authUrl;
         return;
       }
-      const firstError = result.errors[0];
       setTopicStatus(
         topicId,
         result.errors.length > 0
-          ? `Topic pull finished with ${result.errors.length} error${result.errors.length === 1 ? "" : "s"}. ${firstError ? `First: ${firstError}` : ""}`
-          : `Pulled ${result.filesImported} file${result.filesImported === 1 ? "" : "s"} into this topic.`,
+          ? `Topic push finished with ${result.errors.length} error${result.errors.length === 1 ? "" : "s"}.`
+          : `Pushed ${result.questionsExported} question${result.questionsExported === 1 ? "" : "s"} and ${result.filesExported} file${result.filesExported === 1 ? "" : "s"} to Drive.`,
       );
     } catch (err: any) {
-      setTopicStatus(topicId, err?.message || "Topic pull failed.");
+      setTopicStatus(topicId, err?.message || "Topic push failed.");
     } finally {
-      setTopicSyncingId(null);
+      setTopicPushingId(null);
     }
   };
 
-  const handlePushTopicToDrive = async (topicId: string) => {
+  const openPushDestinationPicker = async (
+    mode: "workspace" | "topic",
+    topicId?: string,
+  ) => {
     if (!activeWorkspaceId || !activeWs?.driveConfig?.folderId) return;
-    setTopicPushingId(topicId);
-    setTopicStatus(topicId, "Pushing topic to Drive…");
+    setPushPicker({ mode, topicId, folders: [], loading: true });
     try {
-      const result = await exportTopic(
-        activeWorkspaceId,
-        topicId,
-        activeWs.driveConfig.subFolderId,
-      );
+      const folders = await fetchDriveSubfolders(activeWorkspaceId);
+      setPushPicker({ mode, topicId, folders, loading: false });
+    } catch (err: any) {
+      setPushPicker({ mode, topicId, folders: [], loading: false });
+      const message = err?.message || "Failed to load Drive folders.";
+      if (mode === "topic" && topicId) setTopicStatus(topicId, message);
+      else setDriveFileSyncStatus(message);
+    }
+  };
+
+  const handlePushToDrive = () => {
+    if (!activeWs?.driveConfig?.folderId) return;
+    if (currentSubFolder) {
+      void pushWorkspaceToDrive(currentSubFolder.id);
+      return;
+    }
+    void openPushDestinationPicker("workspace");
+  };
+
+  const handlePushTopicToDrive = (topicId: string) => {
+    if (!activeWs?.driveConfig?.folderId) return;
+    if (currentSubFolder) {
+      void pushTopicToDrive(topicId, currentSubFolder.id);
+      return;
+    }
+    void openPushDestinationPicker("topic", topicId);
+  };
+
+  const handlePushPickerDestination = (targetFolderId: string) => {
+    const picker = pushPicker;
+    if (!picker) return;
+    setPushPicker(null);
+    if (picker.mode === "topic" && picker.topicId) {
+      void pushTopicToDrive(picker.topicId, targetFolderId);
+    } else {
+      void pushWorkspaceToDrive(targetFolderId);
+    }
+  };
+
+  const setTopicStatus = (topicId: string, value: string) => {
+    setTopicDriveStatus((prev) => ({ ...prev, [topicId]: value }));
+  };
+
+  const handlePullTopicFromDrive = async (topicId: string) => {
+    if (!activeWorkspaceId || !activeWs?.driveConfig?.folderId) return;
+    setTopicSyncingId(topicId);
+    setTopicStatus(topicId, "Pulling topic from Drive…");
+    try {
+      const result = await syncTopic(activeWorkspaceId, topicId);
       if ("needsAuth" in result && result.needsAuth) {
         window.location.href = result.authUrl;
         return;
       }
+      const firstError = result.errors[0];
       setTopicStatus(
         topicId,
         result.errors.length > 0
-          ? `Topic push finished with ${result.errors.length} error${result.errors.length === 1 ? "" : "s"}.`
-          : `Pushed ${result.questionsExported} question${result.questionsExported === 1 ? "" : "s"} and ${result.filesExported} file${result.filesExported === 1 ? "" : "s"} to Drive.`,
+          ? `Topic pull finished with ${result.errors.length} error${result.errors.length === 1 ? "" : "s"}. ${firstError ? `First: ${firstError}` : ""}`
+          : `Pulled ${result.filesImported} file${result.filesImported === 1 ? "" : "s"} into this topic.`,
       );
     } catch (err: any) {
-      setTopicStatus(topicId, err?.message || "Topic push failed.");
+      setTopicStatus(topicId, err?.message || "Topic pull failed.");
     } finally {
-      setTopicPushingId(null);
+      setTopicSyncingId(null);
     }
   };
 
@@ -1020,7 +1075,142 @@ export default function Sidebar() {
   };
 
   return (
-    <aside className="w-72 border-r border-slate-800 flex flex-col bg-slate-900/50 shrink-0">
+    <>
+      {pushPicker && (
+        <div
+          className="fixed inset-0 z-50 flex items-center justify-center bg-black/60"
+          onClick={() => !pushPicker.loading && setPushPicker(null)}
+        >
+          <div
+            className="w-80 rounded-xl border border-slate-700 bg-slate-900 p-4 shadow-2xl"
+            onClick={(e) => e.stopPropagation()}
+          >
+            <div className="mb-3 flex items-center justify-between gap-3">
+              <div>
+                <h3 className="text-sm font-semibold text-slate-200">
+                  Choose Drive destination
+                </h3>
+                <p className="mt-0.5 text-[11px] text-slate-500">
+                  {pushPicker.mode === "topic"
+                    ? "Push this topic into the selected Drive folder."
+                    : "Push this local workspace into the selected Drive folder."}
+                </p>
+              </div>
+              <button
+                onClick={() => setPushPicker(null)}
+                className="text-slate-500 hover:text-slate-300"
+                disabled={pushPicker.loading}
+              >
+                <X className="h-4 w-4" />
+              </button>
+            </div>
+
+            {pushPicker.loading ? (
+              <div className="flex items-center justify-center gap-2 py-6 text-xs text-slate-400">
+                <Loader2 className="h-4 w-4 animate-spin" />
+                Loading Drive folders…
+              </div>
+            ) : (
+              <>
+                <div className="max-h-52 space-y-1 overflow-y-auto">
+                  {activeWs?.driveConfig?.folderId && (
+                    <button
+                      type="button"
+                      onClick={() =>
+                        handlePushPickerDestination(activeWs.driveConfig!.folderId)
+                      }
+                      className="flex w-full items-center gap-2 rounded-lg px-3 py-2 text-left text-xs text-slate-300 hover:bg-slate-800"
+                    >
+                      <FolderOpen className="h-3.5 w-3.5 shrink-0 text-slate-500" />
+                      <span className="min-w-0 flex-1 truncate italic text-slate-400">
+                        {activeWs.driveConfig.folderName || "Linked root folder"}
+                      </span>
+                    </button>
+                  )}
+                  {pushPicker.folders.map((folder) => (
+                    <button
+                      key={folder.id}
+                      type="button"
+                      onClick={() => handlePushPickerDestination(folder.id)}
+                      className="flex w-full items-center gap-2 rounded-lg px-3 py-2 text-left text-xs text-slate-200 hover:bg-slate-800"
+                    >
+                      <FolderOpen className="h-3.5 w-3.5 shrink-0 text-cyan-400" />
+                      <span className="min-w-0 flex-1 truncate">
+                        {folder.name}
+                      </span>
+                    </button>
+                  ))}
+                  {pushPicker.folders.length === 0 && (
+                    <p className="px-3 py-2 text-xs text-slate-500">
+                      No subfolders found. Choose the linked root folder above
+                      or create a new folder below.
+                    </p>
+                  )}
+                </div>
+
+                <form
+                  className="mt-3 flex gap-2"
+                  onSubmit={async (e) => {
+                    e.preventDefault();
+                    const name = pushPickerNewFolderName.trim();
+                    if (!name || !activeWorkspaceId) return;
+                    setPushPickerCreatingFolder(true);
+                    try {
+                      const created = await createDriveSubfolder(
+                        activeWorkspaceId,
+                        name,
+                      );
+                      if ("needsAuth" in created) {
+                        window.location.href = created.authUrl;
+                        return;
+                      }
+                      setPushPicker((prev) =>
+                        prev
+                          ? { ...prev, folders: [...prev.folders, created] }
+                          : prev,
+                      );
+                      setPushPickerNewFolderName("");
+                    } catch (err: any) {
+                      const message = err?.message || "Failed to create folder";
+                      if (pushPicker.mode === "topic" && pushPicker.topicId) {
+                        setTopicStatus(pushPicker.topicId, message);
+                      } else {
+                        setDriveFileSyncStatus(message);
+                      }
+                    } finally {
+                      setPushPickerCreatingFolder(false);
+                    }
+                  }}
+                >
+                  <input
+                    value={pushPickerNewFolderName}
+                    onChange={(e) => setPushPickerNewFolderName(e.target.value)}
+                    placeholder="New folder name…"
+                    className="min-w-0 flex-1 rounded-lg border border-slate-700 bg-slate-800 px-2 py-1.5 text-xs text-slate-200 placeholder:text-slate-500 focus:border-cyan-500 focus:outline-none"
+                  />
+                  <button
+                    type="submit"
+                    disabled={
+                      !pushPickerNewFolderName.trim() ||
+                      pushPickerCreatingFolder
+                    }
+                    className="flex items-center gap-1 rounded-lg bg-cyan-700 px-2.5 py-1.5 text-xs font-medium text-white hover:bg-cyan-600 disabled:opacity-40"
+                  >
+                    {pushPickerCreatingFolder ? (
+                      <Loader2 className="h-3 w-3 animate-spin" />
+                    ) : (
+                      <Plus className="h-3 w-3" />
+                    )}
+                    Create
+                  </button>
+                </form>
+              </>
+            )}
+          </div>
+        </div>
+      )}
+
+      <aside className="w-72 border-r border-slate-800 flex flex-col bg-slate-900/50 shrink-0">
       {/* Workspace switcher */}
       <WorkspaceSwitcher />
 
@@ -1060,6 +1250,32 @@ export default function Sidebar() {
                 sync from inside that selected folder.
               </p>
             )}
+            {canPushLocalDrive && (
+              <div className="mt-2 space-y-1.5">
+                <p className="text-[10px] text-slate-600">
+                  Push local workspace to Drive
+                </p>
+                <button
+                  type="button"
+                  onClick={handlePushToDrive}
+                  disabled={pushing}
+                  className="flex w-full items-center justify-center gap-1 rounded-md border border-cyan-500/20 bg-cyan-500/10 px-2 py-1 text-[11px] font-medium text-cyan-300 transition-colors hover:bg-cyan-500/15 disabled:opacity-40 disabled:hover:bg-cyan-500/10"
+                  title="Choose a Drive folder and push topics, questions, and workspace files into it"
+                >
+                  {pushing ? (
+                    <Loader2 className="w-3 h-3 animate-spin" />
+                  ) : (
+                    <Upload className="w-3 h-3" />
+                  )}
+                  {pushing ? "Pushing…" : "Choose folder & push"}
+                </button>
+                {driveFileSyncStatus && (
+                  <p className="text-[10px] leading-relaxed text-slate-500">
+                    {driveFileSyncStatus}
+                  </p>
+                )}
+              </div>
+            )}
             {canSyncDriveFolder && (
               <div className="mt-2 space-y-1.5">
                 <p className="text-[10px] text-slate-600">
@@ -1393,13 +1609,13 @@ export default function Sidebar() {
                                 <Download className="w-3 h-3" /> Download
                               </button>
 
-                              {canSyncDriveFolder && (
+                              {canPushDriveDestination && (
                                 <>
                                   <div className="border-t border-slate-700 my-0.5" />
                                   <button
                                     onClick={() => {
                                       setOpenMenuTopicId(null);
-                                      void handlePushTopicToDrive(topic.id);
+                                      handlePushTopicToDrive(topic.id);
                                     }}
                                     disabled={topicBusy || pushing || syncing}
                                     className="w-full flex items-center gap-2 px-3 py-1.5 text-xs text-cyan-300 hover:bg-slate-700 hover:text-cyan-200 disabled:opacity-50 transition-colors"
@@ -1411,21 +1627,23 @@ export default function Sidebar() {
                                     )}
                                     Push topic
                                   </button>
-                                  <button
-                                    onClick={() => {
-                                      setOpenMenuTopicId(null);
-                                      void handlePullTopicFromDrive(topic.id);
-                                    }}
-                                    disabled={topicBusy || pushing || syncing}
-                                    className="w-full flex items-center gap-2 px-3 py-1.5 text-xs text-slate-300 hover:bg-slate-700 hover:text-cyan-300 disabled:opacity-50 transition-colors"
-                                  >
-                                    {topicSyncingId === topic.id ? (
-                                      <Loader2 className="w-3 h-3 animate-spin" />
-                                    ) : (
-                                      <RefreshCw className="w-3 h-3" />
-                                    )}
-                                    Pull topic
-                                  </button>
+                                  {canSyncDriveFolder && (
+                                    <button
+                                      onClick={() => {
+                                        setOpenMenuTopicId(null);
+                                        void handlePullTopicFromDrive(topic.id);
+                                      }}
+                                      disabled={topicBusy || pushing || syncing}
+                                      className="w-full flex items-center gap-2 px-3 py-1.5 text-xs text-slate-300 hover:bg-slate-700 hover:text-cyan-300 disabled:opacity-50 transition-colors"
+                                    >
+                                      {topicSyncingId === topic.id ? (
+                                        <Loader2 className="w-3 h-3 animate-spin" />
+                                      ) : (
+                                        <RefreshCw className="w-3 h-3" />
+                                      )}
+                                      Pull topic
+                                    </button>
+                                  )}
                                 </>
                               )}
 
@@ -1555,6 +1773,7 @@ export default function Sidebar() {
             })}
         </div>
       )}
-    </aside>
+      </aside>
+    </>
   );
 }

package/template/client/src/components/WorkspaceSwitcher.tsx

@@ -335,7 +335,12 @@ export default function WorkspaceSwitcher() {
               <>
                 <div className="space-y-1 max-h-48 overflow-y-auto">
                   <button
-                    onClick={() => runExport(folderPicker.ws)}
+                    onClick={() =>
+                      runExport(
+                        folderPicker.ws,
+                        folderPicker.ws.driveConfig?.folderId,
+                      )
+                    }
                     className="w-full text-left px-3 py-2 rounded-lg text-xs text-slate-300 hover:bg-slate-800 flex items-center gap-2"
                   >
                     <FolderOpen size={13} className="text-slate-500 shrink-0" />

package/template/client/src/ghaConcurrency.ts

@@ -0,0 +1,216 @@
+// ─── Shared GitHub Actions concurrency helpers ─────────────────────────
+// Used by the GitHub Actions Lab to evaluate `concurrency:` blocks against
+// a simulated github context AND to enforce GitHub's queue/cancel rules on
+// the actual `act` runs triggered from the lab UI.
+
+import { parse as parseYaml } from "yaml";
+
+// ─── Types ───────────────────────────────────────────────────────────────
+
+/**
+ * Subset of `github.*` context fields used when evaluating a concurrency
+ * group expression. Kept narrow on purpose so we don't oversell what the
+ * tiny expression engine below can resolve.
+ */
+export interface GhaConcurrencyContext {
+  event_name: string;
+  ref: string;
+  head_ref: string;
+  workflow: string;
+}
+
+export interface ParsedConcurrency {
+  groupExpr: string;
+  cancelExpr: string;
+}
+
+export type GhaConcurrencyRunStatus =
+  | "pending"
+  | "running"
+  | "completed"
+  | "cancelled";
+
+/**
+ * One record per Run button click. Records survive in memory for the
+ * lifetime of the modal so the user can see the full timeline of how
+ * GitHub's concurrency rules played out.
+ */
+export interface GhaConcurrencyRun {
+  id: string;
+  seq: number;
+  command: string;
+  /** github.event_name when the run was triggered. */
+  eventName: string;
+  /** Workflow file path used for the run. */
+  workflowPath: string;
+  /** Evaluated group key — empty string when no concurrency block exists. */
+  groupKey: string;
+  /** Evaluated cancel-in-progress flag — false when not declared. */
+  cancelInProgress: boolean;
+  /** Snapshot of the github.* context the run was evaluated against. */
+  context: GhaConcurrencyContext;
+  status: GhaConcurrencyRunStatus;
+  startedAt?: number;
+  endedAt?: number;
+  exitCode?: number;
+  cancelReason?: string;
+}
+
+// ─── Parsing ────────────────────────────────────────────────────────────
+
+/**
+ * Extract the workflow-level `concurrency` block. Tolerates both shapes
+ * GitHub accepts (`concurrency: my-group` and the long `group:` form).
+ * Returns null when the workflow doesn't declare concurrency.
+ */
+export function parseConcurrencyBlock(
+  yaml: string | undefined,
+): ParsedConcurrency | null {
+  if (!yaml) return null;
+  let doc: unknown;
+  try {
+    doc = parseYaml(yaml);
+  } catch {
+    return null;
+  }
+  if (!doc || typeof doc !== "object") return null;
+  const raw = (doc as Record<string, unknown>).concurrency;
+  if (raw == null) return null;
+  if (typeof raw === "string") {
+    return { groupExpr: raw, cancelExpr: "false" };
+  }
+  if (typeof raw === "object") {
+    const obj = raw as Record<string, unknown>;
+    const group = typeof obj.group === "string" ? obj.group : "";
+    const cancel = obj["cancel-in-progress"];
+    const cancelExpr =
+      typeof cancel === "boolean"
+        ? String(cancel)
+        : typeof cancel === "string"
+          ? cancel
+          : "false";
+    return { groupExpr: group, cancelExpr };
+  }
+  return null;
+}
+
+// ─── Expression engine ─────────────────────────────────────────────────
+
+/**
+ * Resolve `github.X` against the simulated context. Returns undefined for
+ * any other namespace so unknown references render as empty (matching
+ * GitHub's behaviour for undefined expressions inside `${{ ... }}`).
+ */
+function resolveGithubPath(
+  path: string,
+  ctx: GhaConcurrencyContext,
+): string | undefined {
+  if (!path.startsWith("github.")) return undefined;
+  const key = path.slice("github.".length) as keyof GhaConcurrencyContext;
+  const value = ctx[key];
+  return typeof value === "string" ? value : undefined;
+}
+
+/**
+ * Evaluate one `${{ … }}` expression. Supports the subset real workflows
+ * use when defining concurrency keys:
+ *   - github.X
+ *   - 'string literal'
+ *   - true / false / integer literals
+ *   - X || Y  (coalesce — first non-empty wins, GitHub semantics)
+ *   - X == Y  (string equality → 'true'/'false')
+ */
+function evalConcurrencyExpr(expr: string, ctx: GhaConcurrencyContext): string {
+  const trimmed = expr.trim();
+  if (!trimmed) return "";
+
+  // Equality binds tighter than `||` in our tiny grammar (matches the way
+  // real workflows are normally written: `event_name == 'pull_request'`).
+  if (trimmed.includes("==")) {
+    const [lhs, rhs] = trimmed.split("==").map((s) => s.trim());
+    const l = evalConcurrencyExpr(lhs, ctx);
+    const r = evalConcurrencyExpr(rhs, ctx);
+    return l === r ? "true" : "false";
+  }
+
+  // Coalesce: walk left-to-right, return the first non-empty value.
+  if (trimmed.includes("||")) {
+    for (const part of trimmed.split("||")) {
+      const value = evalConcurrencyExpr(part, ctx);
+      if (value) return value;
+    }
+    return "";
+  }
+
+  const literal = trimmed.match(/^'([^']*)'$/);
+  if (literal) return literal[1];
+
+  if (trimmed === "true" || trimmed === "false") return trimmed;
+  if (/^-?\d+$/.test(trimmed)) return trimmed;
+
+  const resolved = resolveGithubPath(trimmed, ctx);
+  return resolved ?? "";
+}
+
+/**
+ * Replace every `${{ … }}` placeholder in `template` with the value its
+ * inner expression evaluates to against `ctx`.
+ */
+export function renderConcurrencyTemplate(
+  template: string,
+  ctx: GhaConcurrencyContext,
+): string {
+  if (!template) return "";
+  return template.replace(/\$\{\{\s*([\s\S]*?)\s*\}\}/g, (_match, inner) =>
+    evalConcurrencyExpr(String(inner), ctx),
+  );
+}
+
+/**
+ * Compute the (groupKey, cancelInProgress) pair for a hypothetical run.
+ * When the workflow doesn't declare a concurrency block, returns
+ * (empty key, false) which means "no scheduling constraints — treat as
+ * its own group with no cancellation".
+ */
+export function evaluateConcurrencyFor(
+  parsed: ParsedConcurrency | null,
+  ctx: GhaConcurrencyContext,
+): { groupKey: string; cancelInProgress: boolean } {
+  if (!parsed) return { groupKey: "", cancelInProgress: false };
+  const groupKey = renderConcurrencyTemplate(parsed.groupExpr, ctx);
+  const cancelRaw = renderConcurrencyTemplate(parsed.cancelExpr, ctx)
+    .trim()
+    .toLowerCase();
+  return { groupKey, cancelInProgress: cancelRaw === "true" };
+}
+
+/**
+ * Derive a plausible default github.* context from a selected `act` event
+ * name. We don't have the real one act injects, but these defaults are
+ * close enough that the evaluated group keys feel realistic.
+ */
+export function defaultContextForEvent(
+  eventName: string,
+  workflowPath: string,
+  branch: string,
+  prNumber: number,
+  headRef: string,
+): GhaConcurrencyContext {
+  const workflowName = workflowPath
+    .replace(/^\.github\/workflows\//, "")
+    .replace(/\.ya?ml$/, "");
+  if (eventName === "pull_request") {
+    return {
+      event_name: eventName,
+      ref: `refs/pull/${prNumber}/merge`,
+      head_ref: headRef,
+      workflow: workflowName,
+    };
+  }
+  return {
+    event_name: eventName,
+    ref: `refs/heads/${branch}`,
+    head_ref: "",
+    workflow: workflowName,
+  };
+}