create-interview-cockpit 0.22.0 → 0.23.1

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,
+  };
+}

package/template/client/src/githubActionsLab.ts

@@ -1,4 +1,5 @@
 import type { GithubActionsLabWorkspace } from "./types";
+import type { GithubActionsLabEnvironment } from "./types";
 
 // ─── Default Lab Template ────────────────────────────────────────────────
 //
@@ -401,6 +402,41 @@ export const REACT_VITE_TYPESCRIPT_GHA_LAB: GithubActionsLabWorkspace = {
 
 // ─── Helpers (mirror infraLab.ts API surface) ────────────────────────────
 
+function cloneGhaLabEnvironment(
+  environment?: GithubActionsLabEnvironment,
+): GithubActionsLabEnvironment | undefined {
+  if (!environment || typeof environment !== "object") return undefined;
+
+  const cloneEntries = (entries: GithubActionsLabEnvironment["variables"]) =>
+    Array.isArray(entries)
+      ? entries
+          .filter(
+            (entry) =>
+              entry &&
+              typeof entry.name === "string" &&
+              typeof entry.value === "string",
+          )
+          .map((entry) => ({
+            name: entry.name,
+            value: entry.value,
+            ...(entry.enabled === false ? { enabled: false } : {}),
+          }))
+      : [];
+
+  const variables = cloneEntries(environment.variables);
+  const secrets = cloneEntries(environment.secrets);
+  const env = cloneEntries(environment.env);
+  if (variables.length === 0 && secrets.length === 0 && env.length === 0) {
+    return undefined;
+  }
+
+  return {
+    ...(variables.length ? { variables } : {}),
+    ...(secrets.length ? { secrets } : {}),
+    ...(env.length ? { env } : {}),
+  };
+}
+
 export function cloneGhaLabWorkspace(
   workspace?: GithubActionsLabWorkspace | null,
 ): GithubActionsLabWorkspace {
@@ -415,6 +451,7 @@ export function cloneGhaLabWorkspace(
   )
     ? source.activeFile
     : (Object.keys(sourceFiles)[0] ?? ".github/workflows/ci.yml");
+  const environment = cloneGhaLabEnvironment(source.environment);
 
   return {
     version: 1,
@@ -433,6 +470,7 @@ export function cloneGhaLabWorkspace(
     ...(source.includeRunHistoryInContext
       ? { includeRunHistoryInContext: true }
       : {}),
+    ...(environment ? { environment } : {}),
   };
 }
 
@@ -517,6 +555,9 @@ export function parseGhaLabWorkspace(
       ...(parsed.includeRunHistoryInContext === true
         ? { includeRunHistoryInContext: true }
         : {}),
+      ...(parsed.environment && typeof parsed.environment === "object"
+        ? { environment: parsed.environment as GithubActionsLabEnvironment }
+        : {}),
     });
   } catch {
     return null;

package/template/client/src/types.ts

@@ -49,6 +49,21 @@ export interface InfraLabWorkspace {
   files: Record<string, string>;
 }
 
+export interface GithubActionsLabEnvironmentEntry {
+  name: string;
+  value: string;
+  enabled?: boolean;
+}
+
+export interface GithubActionsLabEnvironment {
+  /** Values available to workflows as `${{ vars.NAME }}` through act's --var-file. */
+  variables?: GithubActionsLabEnvironmentEntry[];
+  /** Values available to workflows as `${{ secrets.NAME }}` through act's --secret-file. */
+  secrets?: GithubActionsLabEnvironmentEntry[];
+  /** Runner/container environment values available to shell steps as `$NAME`. */
+  env?: GithubActionsLabEnvironmentEntry[];
+}
+
 export interface GithubActionsLabWorkspace {
   version: 1;
   label: string;
@@ -64,6 +79,8 @@ export interface GithubActionsLabWorkspace {
    * (job statuses, durations, exit codes) instead of just the YAML.
    */
   includeRunHistoryInContext?: boolean;
+  /** Local act inputs mirroring GitHub repository variables, secrets, and runner env. */
+  environment?: GithubActionsLabEnvironment;
 }
 
 export interface WorkspaceMeta {

package/template/client/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["./src/app.tsx","./src/api.ts","./src/browsersecuritytemplates.ts","./src/enterpriselocallab.ts","./src/githubactionslab.ts","./src/infralab.ts","./src/main.tsx","./src/reactlab.ts","./src/store.ts","./src/types.ts","./src/vite-env.d.ts","./src/components/aisettingsmodal.tsx","./src/components/annotationdialog.tsx","./src/components/browsersecuritylabmodal.tsx","./src/components/canvaslabmodal.tsx","./src/components/chatmessage.tsx","./src/components/chatview.tsx","./src/components/codecontextpanel.tsx","./src/components/codelineannotationpopup.tsx","./src/components/coderunnermodal.tsx","./src/components/deploymentlabmodal.tsx","./src/components/docrefmodal.tsx","./src/components/fileattachments.tsx","./src/components/filepickermodal.tsx","./src/components/fileviewermodal.tsx","./src/components/ghahistorypanel.tsx","./src/components/ghajobspanel.tsx","./src/components/gitdiffpanel.tsx","./src/components/gitdiffviewermodal.tsx","./src/components/githubactionslabmodal.tsx","./src/components/infralabmodal.tsx","./src/components/labspanel.tsx","./src/components/linkedconvospicker.tsx","./src/components/markdownrenderer.tsx","./src/components/mermaiddiagram.tsx","./src/components/notesmodal.tsx","./src/components/plotembed.tsx","./src/components/sidebar.tsx","./src/components/textannotator.tsx","./src/components/vizcraftembed.tsx","./src/components/workspaceswitcher.tsx"],"version":"5.9.3"}
+{"root":["./src/app.tsx","./src/api.ts","./src/browsersecuritytemplates.ts","./src/enterpriselocallab.ts","./src/ghaconcurrency.ts","./src/githubactionslab.ts","./src/infralab.ts","./src/main.tsx","./src/reactlab.ts","./src/store.ts","./src/types.ts","./src/vite-env.d.ts","./src/components/aisettingsmodal.tsx","./src/components/annotationdialog.tsx","./src/components/browsersecuritylabmodal.tsx","./src/components/canvaslabmodal.tsx","./src/components/chatmessage.tsx","./src/components/chatview.tsx","./src/components/codecontextpanel.tsx","./src/components/codelineannotationpopup.tsx","./src/components/coderunnermodal.tsx","./src/components/deploymentlabmodal.tsx","./src/components/docrefmodal.tsx","./src/components/fileattachments.tsx","./src/components/filepickermodal.tsx","./src/components/fileviewermodal.tsx","./src/components/ghaconcurrencypanel.tsx","./src/components/ghahistorypanel.tsx","./src/components/ghajobspanel.tsx","./src/components/gitdiffpanel.tsx","./src/components/gitdiffviewermodal.tsx","./src/components/githubactionslabmodal.tsx","./src/components/infralabmodal.tsx","./src/components/labspanel.tsx","./src/components/linkedconvospicker.tsx","./src/components/markdownrenderer.tsx","./src/components/mermaiddiagram.tsx","./src/components/notesmodal.tsx","./src/components/plotembed.tsx","./src/components/sidebar.tsx","./src/components/textannotator.tsx","./src/components/vizcraftembed.tsx","./src/components/workspaceswitcher.tsx"],"version":"5.9.3"}

package/template/cockpit.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.20.0"
+  "version": "0.22.0"
 }

package/template/server/src/gha-runner.ts

@@ -13,6 +13,19 @@ interface GithubActionsLabWorkspace {
   files: Record<string, string>;
   defaultEvent?: string;
   defaultWorkflow?: string;
+  environment?: GithubActionsLabEnvironment;
+}
+
+interface GithubActionsLabEnvironmentEntry {
+  name: string;
+  value: string;
+  enabled?: boolean;
+}
+
+interface GithubActionsLabEnvironment {
+  variables?: GithubActionsLabEnvironmentEntry[];
+  secrets?: GithubActionsLabEnvironmentEntry[];
+  env?: GithubActionsLabEnvironmentEntry[];
 }
 
 type OutputKind = "stdout" | "stderr" | "info";
@@ -69,8 +82,11 @@ export type GhaStreamMessage =
 
 const MAX_FILE_COUNT = 60;
 const MAX_TOTAL_SOURCE_BYTES = 1_000_000;
+const MAX_GHA_ENV_ENTRY_COUNT = 80;
+const MAX_GHA_ENV_TOTAL_BYTES = 100_000;
 const MAX_LOG_CHARS = 400_000;
 const SOURCE_MANIFEST = ".gha-source-files.json";
+const GHA_ENV_NAME_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
 
 // `act` accepts these events; we restrict to common ones so the console
 // can't be used to run arbitrary subcommands.
@@ -105,6 +121,21 @@ const ALLOWED_ACT_FLAGS = new Set([
   "-v",
 ]);
 
+// act asks an interactive first-run question for runner image size unless it
+// already has platform mappings. The lab console cannot answer arrow-key
+// prompts cleanly, so we inject the Medium image mappings by default. Users can
+// still override with -P / --platform in the command.
+const DEFAULT_ACT_PLATFORM_ARGS = [
+  "-P",
+  "ubuntu-latest=catthehacker/ubuntu:act-latest",
+  "-P",
+  "ubuntu-24.04=catthehacker/ubuntu:act-24.04",
+  "-P",
+  "ubuntu-22.04=catthehacker/ubuntu:act-22.04",
+  "-P",
+  "ubuntu-20.04=catthehacker/ubuntu:act-20.04",
+];
+
 // ─── Utilities ───────────────────────────────────────────────────────────
 
 function getGhaRunsDir(): string {
@@ -140,6 +171,69 @@ function assertSafeRelativePath(filePath: string, label: string): void {
   }
 }
 
+function parseEnvironmentEntries(
+  input: unknown,
+  label: string,
+): GithubActionsLabEnvironmentEntry[] {
+  if (!Array.isArray(input)) return [];
+  if (input.length > MAX_GHA_ENV_ENTRY_COUNT) {
+    throw new Error(
+      `${label} exceeds the ${MAX_GHA_ENV_ENTRY_COUNT} item limit`,
+    );
+  }
+
+  let totalBytes = 0;
+  return input
+    .filter((entry): entry is Record<string, unknown> => {
+      return !!entry && typeof entry === "object";
+    })
+    .map((entry) => {
+      const name = typeof entry.name === "string" ? entry.name.trim() : "";
+      if (!name) return null;
+      if (!GHA_ENV_NAME_RE.test(name)) {
+        throw new Error(
+          `${label} name '${name}' is invalid. Use letters, numbers, and underscores; do not start with a number.`,
+        );
+      }
+      const value = typeof entry.value === "string" ? entry.value : "";
+      totalBytes += Buffer.byteLength(name, "utf8");
+      totalBytes += Buffer.byteLength(value, "utf8");
+      if (totalBytes > MAX_GHA_ENV_TOTAL_BYTES) {
+        throw new Error(`${label} values exceed the allowed size limit`);
+      }
+      return {
+        name,
+        value,
+        ...(entry.enabled === false ? { enabled: false } : {}),
+      };
+    })
+    .filter((entry): entry is GithubActionsLabEnvironmentEntry => !!entry);
+}
+
+function parseWorkspaceEnvironment(
+  input: unknown,
+): GithubActionsLabEnvironment | undefined {
+  if (!input || typeof input !== "object") return undefined;
+  const candidate = input as Record<string, unknown>;
+  const variables = parseEnvironmentEntries(
+    candidate.variables,
+    "GitHub Actions variable",
+  );
+  const secrets = parseEnvironmentEntries(
+    candidate.secrets,
+    "GitHub Actions secret",
+  );
+  const env = parseEnvironmentEntries(candidate.env, "GitHub Actions env");
+  if (variables.length === 0 && secrets.length === 0 && env.length === 0) {
+    return undefined;
+  }
+  return {
+    ...(variables.length ? { variables } : {}),
+    ...(secrets.length ? { secrets } : {}),
+    ...(env.length ? { env } : {}),
+  };
+}
+
 function parseWorkspace(input: unknown): GithubActionsLabWorkspace {
   if (!input || typeof input !== "object") {
     throw new Error("workspace payload is required");
@@ -173,6 +267,7 @@ function parseWorkspace(input: unknown): GithubActionsLabWorkspace {
   if (totalBytes > MAX_TOTAL_SOURCE_BYTES) {
     throw new Error("workspace source exceeds the allowed size limit");
   }
+  const environment = parseWorkspaceEnvironment(candidate.environment);
   return {
     version: 1,
     label:
@@ -192,6 +287,7 @@ function parseWorkspace(input: unknown): GithubActionsLabWorkspace {
       typeof candidate.defaultWorkflow === "string"
         ? candidate.defaultWorkflow
         : undefined,
+    ...(environment ? { environment } : {}),
     files,
   };
 }
@@ -258,6 +354,72 @@ async function syncWorkspaceToSession(
   return workspaceDir;
 }
 
+function escapeDotenvValue(value: string): string {
+  return `"${value
+    .replace(/\\/g, "\\\\")
+    .replace(/\r/g, "")
+    .replace(/\n/g, "\\n")
+    .replace(/"/g, '\\"')}"`;
+}
+
+function formatEnvironmentFile(
+  entries: GithubActionsLabEnvironmentEntry[],
+): string {
+  return `${entries
+    .filter((entry) => entry.enabled !== false)
+    .map((entry) => `${entry.name}=${escapeDotenvValue(entry.value)}`)
+    .join("\n")}\n`;
+}
+
+async function buildActEnvironmentArgs(
+  runDir: string,
+  workspace: GithubActionsLabWorkspace,
+): Promise<{ args: string[]; summary: string[] }> {
+  const args: string[] = [];
+  const summary: string[] = [];
+  const specs: Array<{
+    key: keyof GithubActionsLabEnvironment;
+    flag: string;
+    fileName: string;
+    label: string;
+  }> = [
+    {
+      key: "variables",
+      flag: "--var-file",
+      fileName: "act-vars.env",
+      label: "variable",
+    },
+    {
+      key: "secrets",
+      flag: "--secret-file",
+      fileName: "act-secrets.env",
+      label: "secret",
+    },
+    {
+      key: "env",
+      flag: "--env-file",
+      fileName: "act-env.env",
+      label: "runner env",
+    },
+  ];
+
+  for (const spec of specs) {
+    const entries = (workspace.environment?.[spec.key] ?? []).filter(
+      (entry) => entry.enabled !== false,
+    );
+    if (entries.length === 0) continue;
+
+    const filePath = path.join(runDir, spec.fileName);
+    await fs.writeFile(filePath, formatEnvironmentFile(entries), "utf8");
+    args.push(spec.flag, filePath);
+    summary.push(
+      `${entries.length} ${spec.label}${entries.length === 1 ? "" : "s"}`,
+    );
+  }
+
+  return { args, summary };
+}
+
 // ─── Command parsing ────────────────────────────────────────────────────
 
 function splitCommand(command: string): string[] {
@@ -304,6 +466,24 @@ interface ParsedActCommand {
   displayCommand: string;
 }
 
+function hasPlatformOverride(args: string[]): boolean {
+  return args.some(
+    (arg) =>
+      arg === "-P" ||
+      arg === "--platform" ||
+      arg.startsWith("-P=") ||
+      arg.startsWith("--platform="),
+  );
+}
+
+function withDefaultActPlatforms(args: string[]): {
+  args: string[];
+  injected: boolean;
+} {
+  if (hasPlatformOverride(args)) return { args, injected: false };
+  return { args: [...args, ...DEFAULT_ACT_PLATFORM_ARGS], injected: true };
+}
+
 function parseActCommand(command: string): ParsedActCommand {
   const tokens = splitCommand(command);
   if (tokens.length === 0) throw new Error("Type a command to run");
@@ -681,6 +861,7 @@ export async function streamGhaCommand(
   const workspace = parseWorkspace(input.workspace);
 
   const parsed = parseActCommand(input.command);
+  const platformArgs = withDefaultActPlatforms(parsed.args);
   const sessionKey =
     input.fileId ?? input.questionId ?? `draft-${randomUUID()}`;
   const runId = randomUUID();
@@ -688,6 +869,8 @@ export async function streamGhaCommand(
   const runDir = path.join(getGhaRunsDir(), runId);
   const workspaceDir = await syncWorkspaceToSession(sessionKey, workspace);
   await fs.mkdir(runDir, { recursive: true });
+  const environmentArgs = await buildActEnvironmentArgs(runDir, workspace);
+  const actArgs = [...platformArgs.args, ...environmentArgs.args];
 
   let logs = "";
   let status: "completed" | "failed" = "completed";
@@ -696,12 +879,26 @@ export async function streamGhaCommand(
 
   const emit = (msg: GhaStreamMessage) => input.onMessage?.(msg);
   emit({ type: "output", kind: "info", text: parsed.displayCommand });
+  if (platformArgs.injected) {
+    emit({
+      type: "output",
+      kind: "info",
+      text: "[info] Using default Medium act runner image mappings. Pass -P/--platform to override.\n",
+    });
+  }
+  if (environmentArgs.summary.length > 0) {
+    emit({
+      type: "output",
+      kind: "info",
+      text: `[info] Injected ${environmentArgs.summary.join(", ")} into act via temporary files.\n`,
+    });
+  }
 
   // Track per-job status from act's prefixed stdout/stderr lines so the
   // client can render a live DAG in addition to the raw console.
   const tracker = new JobTracker((job) => emit({ type: "job", job }));
 
-  const child = spawn("act", parsed.args, {
+  const child = spawn("act", actArgs, {
     cwd: workspaceDir,
     env: {
       ...process.env,

package/template/server/src/google-drive.ts

@@ -1163,6 +1163,27 @@ async function getOrCreateFolder(
   return folderId;
 }
 
+async function resolveExportFolderId(
+  drive: drive_v3.Drive,
+  ws: storage.WorkspaceMeta,
+  targetFolderId?: string,
+): Promise<string> {
+  const requestedTarget = targetFolderId?.trim();
+  if (requestedTarget) return requestedTarget;
+
+  // If the workspace is currently scoped to a Drive subfolder (for example
+  // Shared Questions/SBD), push back into that same folder. Falling back to
+  // _export here made topic-level pushes from a selected subfolder land in
+  // Shared Questions/_export instead of beside the original topic folders.
+  const selectedSubfolder = ws.driveConfig?.subFolderId?.trim();
+  if (selectedSubfolder) return selectedSubfolder;
+
+  if (!ws.driveConfig?.folderId) {
+    throw new Error("No Drive folder linked to this workspace");
+  }
+  return getOrCreateFolder(drive, ws.driveConfig.folderId, EXPORT_FOLDER_NAME);
+}
+
 async function uploadFileToFolder(
   drive: drive_v3.Drive,
   folderId: string,
@@ -1342,7 +1363,6 @@ export async function exportWorkspace(
   }
 
   const drive = await getExportDriveClient();
-  const { folderId } = ws.driveConfig;
   const result: ExportResult = {
     topicsExported: 0,
     questionsExported: 0,
@@ -1350,10 +1370,9 @@ export async function exportWorkspace(
     errors: [],
   };
 
-  // Use the chosen subfolder directly, or fall back to an "_export" subfolder
-  const exportFolderId =
-    targetFolderId ??
-    (await getOrCreateFolder(drive, folderId, EXPORT_FOLDER_NAME));
+  // Use the chosen subfolder directly. If none was passed, use the workspace's
+  // selected Drive subfolder before falling back to root/_export.
+  const exportFolderId = await resolveExportFolderId(drive, ws, targetFolderId);
   const topics = await storage.getTopicsForWorkspace(workspaceId);
   const ctxDir = storage.getContextFilesDirForWorkspace(workspaceId);
 
@@ -1415,10 +1434,7 @@ export async function exportTopic(
   }
 
   const drive = await getExportDriveClient();
-  const { folderId } = ws.driveConfig;
-  const exportFolderId =
-    targetFolderId ??
-    (await getOrCreateFolder(drive, folderId, EXPORT_FOLDER_NAME));
+  const exportFolderId = await resolveExportFolderId(drive, ws, targetFolderId);
   const topic = (await storage.getTopicsForWorkspace(workspaceId)).find(
     (t) => t.id === topicId,
   );