stageflow 0.25.0 → 0.30.0

package/dist/runstore/sqlite/schema.js

@@ -1,3 +1,57 @@
+export const A2A_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS a2a_contexts (
+  context_id TEXT PRIMARY KEY,
+  caller_id TEXT NOT NULL,
+  created_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS a2a_tasks (
+  task_id TEXT PRIMARY KEY,
+  context_id TEXT NOT NULL,
+  caller_id TEXT NOT NULL,
+  publication_id TEXT NOT NULL,
+  publication_revision TEXT NOT NULL,
+  submission_key TEXT NOT NULL UNIQUE,
+  run_id TEXT,
+  state TEXT NOT NULL,
+  result_json TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS a2a_tasks_context ON a2a_tasks(context_id);
+CREATE INDEX IF NOT EXISTS a2a_tasks_caller ON a2a_tasks(caller_id);
+
+CREATE TABLE IF NOT EXISTS a2a_messages (
+  caller_id TEXT NOT NULL,
+  message_id TEXT NOT NULL,
+  task_id TEXT NOT NULL,
+  operation TEXT NOT NULL,
+  request_hash TEXT NOT NULL,
+  outcome_json TEXT,
+  created_at TEXT NOT NULL,
+  PRIMARY KEY (caller_id, message_id)
+);
+
+CREATE TABLE IF NOT EXISTS a2a_artifacts (
+  artifact_id TEXT PRIMARY KEY,
+  task_id TEXT NOT NULL,
+  name TEXT NOT NULL,
+  media_type TEXT,
+  size INTEGER NOT NULL,
+  content_path TEXT NOT NULL,
+  hash TEXT NOT NULL,
+  created_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS a2a_artifacts_task ON a2a_artifacts(task_id);
+`;
+export const SCHEMA_MIGRATIONS_DDL = `
+CREATE TABLE IF NOT EXISTS schema_migrations (
+  version INTEGER PRIMARY KEY,
+  name TEXT NOT NULL,
+  applied_at TEXT NOT NULL,
+  min_stageflow_version TEXT NOT NULL
+);
+`;
 export const SCHEMA_SQL = `
 CREATE TABLE IF NOT EXISTS runs (
   run_id TEXT PRIMARY KEY,
@@ -14,7 +68,29 @@ CREATE TABLE IF NOT EXISTS runs (
   ci_job_url TEXT,
   pipeline_path TEXT,
   task_path TEXT,
-  project_root TEXT
+  project_root TEXT,
+  repository TEXT,
+  ref TEXT,
+  resolved_sha TEXT,
+  run_branch TEXT,
+  git_author_name TEXT,
+  git_author_email TEXT,
+  cancel_reason TEXT,
+  finished_at TEXT,
+  slimmed_at TEXT,
+  disk_bytes INTEGER,
+  disk_measured_at TEXT,
+  config_origins_json TEXT,
+  pipeline_source TEXT,
+  pipeline_body TEXT,
+  caller_id TEXT,
+  run_manifest TEXT,
+  skip_gates INTEGER
+);
+
+CREATE TABLE IF NOT EXISTS projects (
+  project_root TEXT PRIMARY KEY NOT NULL,
+  created_at TEXT NOT NULL
 );
 
 CREATE TABLE IF NOT EXISTS run_submissions (
@@ -65,6 +141,7 @@ CREATE TABLE IF NOT EXISTS stage_executions (
   envelope_json TEXT,
   cost_usd REAL,
   usage_json TEXT,
+  auto_resume_count INTEGER NOT NULL DEFAULT 0,
   PRIMARY KEY (run_id, stage_id, attempt),
   FOREIGN KEY (run_id) REFERENCES runs(run_id)
 );
@@ -170,3 +247,202 @@ CREATE UNIQUE INDEX IF NOT EXISTS idx_fork_generations_parent_number
 CREATE INDEX IF NOT EXISTS idx_fork_generations_run_replay
   ON fork_generations (run_id, replay_id, created_at);
 `;
+export function ensureCheckoutRootColumn(db) {
+    const cols = db.prepare(`PRAGMA table_info(runs)`).all();
+    if (!cols.some((c) => c.name === "checkout_root")) {
+        db.exec(`ALTER TABLE runs ADD COLUMN checkout_root TEXT`);
+    }
+}
+export function ensureCiIdentityColumns(db) {
+    const cols = db.prepare(`PRAGMA table_info(runs)`).all();
+    const names = new Set(cols.map((c) => c.name));
+    for (const name of ["git_sha", "ci_pr_url", "ci_job_url"]) {
+        if (!names.has(name)) {
+            db.exec(`ALTER TABLE runs ADD COLUMN ${name} TEXT`);
+        }
+    }
+}
+export function ensurePipelineDagColumn(db) {
+    const cols = db.prepare(`PRAGMA table_info(runs)`).all();
+    if (!cols.some((c) => c.name === "pipeline_dag_json")) {
+        db.exec(`ALTER TABLE runs ADD COLUMN pipeline_dag_json TEXT`);
+    }
+}
+export function ensureRunLocatorColumns(db) {
+    const cols = db.prepare(`PRAGMA table_info(runs)`).all();
+    const names = new Set(cols.map((c) => c.name));
+    for (const name of ["pipeline_path", "task_path", "project_root"]) {
+        if (!names.has(name)) {
+            db.exec(`ALTER TABLE runs ADD COLUMN ${name} TEXT`);
+        }
+    }
+}
+export function ensureStageExecutionsTable(db) {
+    db.exec(`
+CREATE TABLE IF NOT EXISTS stage_executions (
+  run_id TEXT NOT NULL,
+  stage_id TEXT NOT NULL,
+  attempt INTEGER NOT NULL,
+  status TEXT NOT NULL,
+  verification_outcome TEXT NOT NULL DEFAULT 'not_run',
+  started_at TEXT,
+  finished_at TEXT,
+  envelope_json TEXT,
+  auto_resume_count INTEGER NOT NULL DEFAULT 0,
+  PRIMARY KEY (run_id, stage_id, attempt),
+  FOREIGN KEY (run_id) REFERENCES runs(run_id)
+);
+CREATE INDEX IF NOT EXISTS idx_stage_executions_run_stage
+  ON stage_executions (run_id, stage_id, attempt);
+`);
+}
+export function ensureStageExecutionAutoResumeCountColumn(db) {
+    const cols = db
+        .prepare(`PRAGMA table_info(stage_executions)`)
+        .all();
+    if (cols.length === 0)
+        return;
+    if (!cols.some((c) => c.name === "auto_resume_count")) {
+        db.exec(`ALTER TABLE stage_executions ADD COLUMN auto_resume_count INTEGER NOT NULL DEFAULT 0`);
+    }
+}
+export function ensureStageExecutionVerificationOutcomeColumn(db) {
+    const cols = db
+        .prepare(`PRAGMA table_info(stage_executions)`)
+        .all();
+    if (!cols.some((c) => c.name === "verification_outcome")) {
+        db.exec(`ALTER TABLE stage_executions ADD COLUMN verification_outcome TEXT NOT NULL DEFAULT 'not_run'`);
+    }
+}
+export function ensureStageExecutionCostColumns(db) {
+    const cols = db
+        .prepare(`PRAGMA table_info(stage_executions)`)
+        .all();
+    const names = new Set(cols.map((c) => c.name));
+    if (!names.has("cost_usd")) {
+        db.exec(`ALTER TABLE stage_executions ADD COLUMN cost_usd REAL`);
+    }
+    if (!names.has("usage_json")) {
+        db.exec(`ALTER TABLE stage_executions ADD COLUMN usage_json TEXT`);
+    }
+}
+export function backfillVerificationOutcomes(db) {
+    db.exec(`
+UPDATE stage_executions
+SET verification_outcome = CASE
+  WHEN status = 'succeeded'
+    AND EXISTS (
+      SELECT 1 FROM verification_check_results AS check_result
+      WHERE check_result.run_id = stage_executions.run_id
+        AND check_result.stage_id = stage_executions.stage_id
+        AND check_result.attempt = stage_executions.attempt
+    )
+    AND NOT EXISTS (
+      SELECT 1 FROM verification_check_results AS check_result
+      WHERE check_result.run_id = stage_executions.run_id
+        AND check_result.stage_id = stage_executions.stage_id
+        AND check_result.attempt = stage_executions.attempt
+        AND check_result.status != 'passed'
+    )
+    THEN 'passed'
+  WHEN status = 'failed'
+    AND EXISTS (
+      SELECT 1 FROM verification_check_results AS check_result
+      WHERE check_result.run_id = stage_executions.run_id
+        AND check_result.stage_id = stage_executions.stage_id
+        AND check_result.attempt = stage_executions.attempt
+    )
+    THEN 'failed'
+  ELSE verification_outcome
+END
+WHERE verification_outcome = 'not_run';
+`);
+}
+export function ensureStageEventsAttemptColumn(db) {
+    const cols = db
+        .prepare(`PRAGMA table_info(stage_events)`)
+        .all();
+    if (!cols.some((c) => c.name === "attempt")) {
+        db.exec(`ALTER TABLE stage_events ADD COLUMN attempt INTEGER NOT NULL DEFAULT 1`);
+        db.exec(`
+CREATE INDEX IF NOT EXISTS idx_stage_events_run_stage_attempt_at
+  ON stage_events (run_id, stage_id, attempt, at);
+`);
+    }
+}
+export function ensureVerificationCheckResultsTable(db) {
+    db.exec(`
+CREATE TABLE IF NOT EXISTS verification_check_results (
+  run_id TEXT NOT NULL,
+  stage_id TEXT NOT NULL,
+  attempt INTEGER NOT NULL,
+  check_id TEXT NOT NULL,
+  check_type TEXT NOT NULL,
+  status TEXT NOT NULL,
+  started_at TEXT,
+  finished_at TEXT,
+  evidence_json TEXT,
+  PRIMARY KEY (run_id, stage_id, attempt, check_id),
+  FOREIGN KEY (run_id, stage_id, attempt)
+    REFERENCES stage_executions(run_id, stage_id, attempt)
+);
+CREATE INDEX IF NOT EXISTS idx_verification_check_results_execution
+  ON verification_check_results (run_id, stage_id, attempt, check_id);
+`);
+}
+export function ensureFeedbackReplayStagePassEnvelopeColumn(db) {
+    const cols = db
+        .prepare(`PRAGMA table_info(feedback_replay_stage_passes)`)
+        .all();
+    if (cols.length === 0)
+        return;
+    if (!cols.some((c) => c.name === "emitted_envelope_json")) {
+        db.exec(`ALTER TABLE feedback_replay_stage_passes ADD COLUMN emitted_envelope_json TEXT`);
+    }
+}
+export function ensureFeedbackReplayStagePassSessionOriginColumn(db) {
+    const cols = db
+        .prepare(`PRAGMA table_info(feedback_replay_stage_passes)`)
+        .all();
+    if (cols.length === 0)
+        return;
+    if (!cols.some((c) => c.name === "session_origin_attempt")) {
+        db.exec(`ALTER TABLE feedback_replay_stage_passes ADD COLUMN session_origin_attempt INTEGER`);
+    }
+}
+export function ensureFeedbackLoopDeferredSendBackColumn(db) {
+    const cols = db
+        .prepare(`PRAGMA table_info(feedback_loops)`)
+        .all();
+    if (cols.length === 0)
+        return;
+    if (!cols.some((c) => c.name === "deferred_send_back_json")) {
+        db.exec(`ALTER TABLE feedback_loops ADD COLUMN deferred_send_back_json TEXT`);
+    }
+}
+export function ensureConfigOriginsColumn(db) {
+    const cols = db.prepare(`PRAGMA table_info(runs)`).all();
+    if (!cols.some((c) => c.name === "config_origins_json")) {
+        db.exec(`ALTER TABLE runs ADD COLUMN config_origins_json TEXT`);
+    }
+}
+export function applyBaselineSchema(db) {
+    db.exec(SCHEMA_MIGRATIONS_DDL);
+    db.exec(SCHEMA_SQL);
+    ensureCheckoutRootColumn(db);
+    ensureCiIdentityColumns(db);
+    ensurePipelineDagColumn(db);
+    ensureRunLocatorColumns(db);
+    ensureStageExecutionsTable(db);
+    ensureStageExecutionVerificationOutcomeColumn(db);
+    ensureStageExecutionCostColumns(db);
+    ensureStageExecutionAutoResumeCountColumn(db);
+    ensureStageEventsAttemptColumn(db);
+    ensureVerificationCheckResultsTable(db);
+    ensureFeedbackReplayStagePassEnvelopeColumn(db);
+    ensureFeedbackReplayStagePassSessionOriginColumn(db);
+    ensureFeedbackLoopDeferredSendBackColumn(db);
+    ensureConfigOriginsColumn(db);
+    db.exec(A2A_SCHEMA_SQL);
+    backfillVerificationOutcomes(db);
+}

package/dist/runstore/sqlite/storeOpenError.d.ts

@@ -0,0 +1,6 @@
+export type StoreOpenErrorCode = "store_integrity_failed" | "store_unsupported_filesystem" | "tmpdir_unusable";
+export declare class StoreOpenError extends Error {
+    readonly code: StoreOpenErrorCode;
+    readonly detail?: Record<string, unknown>;
+    constructor(message: string, code: StoreOpenErrorCode, detail?: Record<string, unknown>);
+}

package/dist/runstore/sqlite/storeOpenError.js

@@ -0,0 +1,11 @@
+export class StoreOpenError extends Error {
+    code;
+    detail;
+    constructor(message, code, detail) {
+        super(message);
+        this.name = "StoreOpenError";
+        this.code = code;
+        if (detail !== undefined)
+            this.detail = detail;
+    }
+}

package/dist/runstore/sqlite/storeSchemaError.d.ts

@@ -0,0 +1,5 @@
+export type StoreSchemaErrorCode = "store_schema_migration_required" | "store_schema_too_new";
+export declare class StoreSchemaError extends Error {
+    readonly code: StoreSchemaErrorCode;
+    constructor(message: string, code: StoreSchemaErrorCode);
+}

package/dist/runstore/sqlite/storeSchemaError.js

@@ -0,0 +1,8 @@
+export class StoreSchemaError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.name = "StoreSchemaError";
+        this.code = code;
+    }
+}

package/dist/runstore/stageExecution.js

@@ -14,6 +14,9 @@ export function deriveExecutionPatchFromEvent(event, current) {
     else if (eventName === "waiting_for_input") {
         patch.status = "waiting_for_input";
     }
+    else if (eventName === "interrupted") {
+        patch.status = "interrupted";
+    }
     else if (event.event === "succeeded" || event.event === "failed") {
         patch.status = event.event;
         patch.finished_at = at;

package/dist/runstore/storeFilesystem.d.ts

@@ -0,0 +1,32 @@
+export declare const ALLOW_NETWORK_STORE_ENV = "STAGEFLOW_ALLOW_NETWORK_STORE";
+export type MountInfoEntry = {
+    mountPoint: string;
+    fsType: string;
+};
+export type StoreFilesystemClassification = {
+    fsType: string | null;
+    mountPoint: string | null;
+    status: "ok" | "refused" | "warn" | "skipped";
+    reason?: string;
+};
+/**
+ * Parse `/proc/self/mountinfo` lines into mount point + fstype pairs.
+ * Field layout: ... mount-point ... - fstype ...
+ */
+export declare function parseMountInfo(content: string): MountInfoEntry[];
+export declare function classifyPathFilesystem(resolvedPath: string, mounts: MountInfoEntry[]): {
+    fsType: string;
+    mountPoint: string;
+} | null;
+export declare function classifyStoreFilesystem(options: {
+    homePath: string;
+    platform?: NodeJS.Platform;
+    mountInfoContent?: string;
+    env?: NodeJS.ProcessEnv;
+}): StoreFilesystemClassification;
+export declare function assertStoreFilesystemSupported(homePath: string, options?: {
+    platform?: NodeJS.Platform;
+    mountInfoContent?: string;
+    env?: NodeJS.ProcessEnv;
+    warn?: (message: string) => void;
+}): StoreFilesystemClassification;

package/dist/runstore/storeFilesystem.js

@@ -0,0 +1,148 @@
+import { readFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { StoreOpenError } from "./sqlite/storeOpenError.js";
+export const ALLOW_NETWORK_STORE_ENV = "STAGEFLOW_ALLOW_NETWORK_STORE";
+const REFUSED_FSTYPES = new Set([
+    "nfs",
+    "nfs4",
+    "cifs",
+    "smbfs",
+    "fuse.sshfs",
+]);
+const WARN_FSTYPES = new Set(["9p", "virtiofs"]);
+/**
+ * Parse `/proc/self/mountinfo` lines into mount point + fstype pairs.
+ * Field layout: ... mount-point ... - fstype ...
+ */
+export function parseMountInfo(content) {
+    const entries = [];
+    for (const line of content.split("\n")) {
+        if (line.trim() === "")
+            continue;
+        const sep = line.indexOf(" - ");
+        if (sep < 0)
+            continue;
+        const left = line.slice(0, sep);
+        const right = line.slice(sep + 3);
+        const leftParts = left.split(" ");
+        const rightParts = right.split(" ");
+        if (leftParts.length < 5 || rightParts.length < 1)
+            continue;
+        const mountPoint = unescapeMountField(leftParts[4]);
+        const fsType = rightParts[0];
+        entries.push({ mountPoint, fsType });
+    }
+    return entries;
+}
+function unescapeMountField(value) {
+    return value
+        .replace(/\\040/g, " ")
+        .replace(/\\011/g, "\t")
+        .replace(/\\012/g, "\n")
+        .replace(/\\134/g, "\\");
+}
+export function classifyPathFilesystem(resolvedPath, mounts) {
+    const target = path.resolve(resolvedPath);
+    let best;
+    let bestLen = -1;
+    for (const entry of mounts) {
+        const mp = path.resolve(entry.mountPoint);
+        if (target === mp || target.startsWith(mp.endsWith("/") ? mp : `${mp}/`)) {
+            if (mp.length > bestLen) {
+                best = entry;
+                bestLen = mp.length;
+            }
+        }
+    }
+    if (best === undefined)
+        return null;
+    return { fsType: best.fsType, mountPoint: best.mountPoint };
+}
+export function classifyStoreFilesystem(options) {
+    const platform = options.platform ?? os.platform();
+    if (platform !== "linux") {
+        return {
+            fsType: null,
+            mountPoint: null,
+            status: "skipped",
+            reason: "filesystem detection is Linux-only (mountinfo)",
+        };
+    }
+    let content = options.mountInfoContent;
+    if (content === undefined) {
+        try {
+            content = readFileSync("/proc/self/mountinfo", "utf8");
+        }
+        catch (err) {
+            return {
+                fsType: null,
+                mountPoint: null,
+                status: "skipped",
+                reason: `mountinfo unreadable: ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+    }
+    const mounts = parseMountInfo(content);
+    const match = classifyPathFilesystem(options.homePath, mounts);
+    if (match === null) {
+        return {
+            fsType: null,
+            mountPoint: null,
+            status: "ok",
+            reason: "no matching mount; treating as local",
+        };
+    }
+    const env = options.env ?? process.env;
+    const allowNetwork = env[ALLOW_NETWORK_STORE_ENV] === "1" ||
+        env[ALLOW_NETWORK_STORE_ENV]?.toLowerCase() === "true";
+    if (REFUSED_FSTYPES.has(match.fsType)) {
+        if (allowNetwork) {
+            return {
+                fsType: match.fsType,
+                mountPoint: match.mountPoint,
+                status: "warn",
+                reason: `network filesystem ${match.fsType} allowed via ${ALLOW_NETWORK_STORE_ENV}`,
+            };
+        }
+        return {
+            fsType: match.fsType,
+            mountPoint: match.mountPoint,
+            status: "refused",
+            reason: `unsupported network filesystem ${match.fsType}`,
+        };
+    }
+    if (WARN_FSTYPES.has(match.fsType)) {
+        return {
+            fsType: match.fsType,
+            mountPoint: match.mountPoint,
+            status: "warn",
+            reason: `${match.fsType} may be unreliable for SQLite WAL`,
+        };
+    }
+    return {
+        fsType: match.fsType,
+        mountPoint: match.mountPoint,
+        status: "ok",
+    };
+}
+export function assertStoreFilesystemSupported(homePath, options) {
+    const classification = classifyStoreFilesystem({
+        homePath,
+        platform: options?.platform,
+        mountInfoContent: options?.mountInfoContent,
+        env: options?.env,
+    });
+    if (classification.status === "refused") {
+        throw new StoreOpenError(`store_unsupported_filesystem: ${classification.fsType} at ${homePath}` +
+            ` (mount ${classification.mountPoint}). Use a local volume, or set ${ALLOW_NETWORK_STORE_ENV}=1 to override (unsupported).`, "store_unsupported_filesystem", {
+            fs_type: classification.fsType,
+            mount_point: classification.mountPoint,
+            path: homePath,
+        });
+    }
+    if (classification.status === "warn") {
+        options?.warn?.(`stageflow: store filesystem warning: ${classification.reason ?? classification.fsType} at ${homePath}`);
+    }
+    return classification;
+}

package/dist/runstore/trackProjection.js

@@ -66,6 +66,8 @@ function deriveReadiness(stage, dag, snapshotsById, halted) {
         return { readiness: "running" };
     if (status === "waiting_for_input")
         return { readiness: "waiting" };
+    if (status === "interrupted")
+        return { readiness: "interrupted" };
     if (halted && !stageStarted(stage)) {
         return { readiness: "skipped" };
     }

package/dist/runstore/workspaceLayout.d.ts

@@ -18,6 +18,19 @@ export declare function stageLogPath(workspaceDir: string, stageId: string): str
 /** @deprecated Use attemptSessionPath with an explicit attempt number. */
 export declare function stageSessionPath(workspaceDir: string, stageId: string): string;
 export declare function isInsideDir(child: string, parent: string): boolean;
+export declare const STAGEFLOW_PATH_DENIED = "stageflow_path_denied";
+export type RealPathContainment = {
+    status: "inside";
+    realPath: string;
+} | {
+    status: "outside";
+    realPath: string;
+} | {
+    status: "missing";
+};
+export declare function classifyRealPathContainment(candidatePath: string, containerDir: string): Promise<RealPathContainment>;
+export declare function resolveEffectiveRealPath(candidatePath: string): Promise<string | undefined>;
+export declare function durableRootFileToolDenial(candidatePath: string, runWorkspaceDir: string, durableRoot: string, allowlistedRoots?: readonly string[]): Promise<typeof STAGEFLOW_PATH_DENIED | undefined>;
 export declare function resolveArtifactTarget(runWorkspaceDir: string, stageId: string, attempt: number, relativePath: string): {
     absolutePath: string;
     runRelativePath: string;

package/dist/runstore/workspaceLayout.js

@@ -63,6 +63,82 @@ export function isInsideDir(child, parent) {
             relative !== ".." &&
             !path.isAbsolute(relative)));
 }
+export const STAGEFLOW_PATH_DENIED = "stageflow_path_denied";
+export async function classifyRealPathContainment(candidatePath, containerDir) {
+    const containerReal = await realpath(containerDir);
+    let fileReal;
+    try {
+        fileReal = await realpath(candidatePath);
+    }
+    catch {
+        return { status: "missing" };
+    }
+    if (isInsideDir(fileReal, containerReal)) {
+        return { status: "inside", realPath: fileReal };
+    }
+    return { status: "outside", realPath: fileReal };
+}
+export async function resolveEffectiveRealPath(candidatePath) {
+    try {
+        return await realpath(candidatePath);
+    }
+    catch {
+        const missing = [];
+        let current = candidatePath;
+        while (true) {
+            missing.unshift(path.basename(current));
+            const parent = path.dirname(current);
+            if (parent === current) {
+                return undefined;
+            }
+            try {
+                const realParent = await realpath(parent);
+                return path.join(realParent, ...missing);
+            }
+            catch {
+                current = parent;
+            }
+        }
+    }
+}
+export async function durableRootFileToolDenial(candidatePath, runWorkspaceDir, durableRoot, allowlistedRoots) {
+    const fileReal = await resolveEffectiveRealPath(candidatePath);
+    if (fileReal === undefined) {
+        return undefined;
+    }
+    let workspaceReal;
+    try {
+        workspaceReal = await realpath(runWorkspaceDir);
+    }
+    catch {
+        return undefined;
+    }
+    if (isInsideDir(fileReal, workspaceReal)) {
+        return undefined;
+    }
+    for (const root of allowlistedRoots ?? []) {
+        try {
+            const allowReal = await realpath(root);
+            if (isInsideDir(fileReal, allowReal)) {
+                return undefined;
+            }
+        }
+        catch {
+            // skip roots that cannot be resolved
+        }
+    }
+    let durableReal;
+    try {
+        durableReal = await realpath(durableRoot);
+    }
+    catch {
+        durableReal = path.resolve(durableRoot);
+    }
+    if (isInsideDir(fileReal, durableReal)) {
+        return STAGEFLOW_PATH_DENIED;
+    }
+    return undefined;
+}
 export function resolveArtifactTarget(runWorkspaceDir, stageId, attempt, relativePath) {
     guardStageId(stageId);
     guardAttempt(attempt);

package/dist/runtime/answerResume.d.ts

@@ -4,6 +4,7 @@ export declare const WAIT_WITHOUT_WORKER_DISPATCH = "stage entered wait without
 export type AnswerResumeAdapterResult = {
     ok: boolean;
     reason?: string;
+    verification?: "failed_retrying";
 };
 export declare function orchestrateAnswerResume(options: {
     prefixMode: "live" | "restart";

package/dist/runtime/answerResume.js

@@ -18,5 +18,7 @@ export async function orchestrateAnswerResume(options) {
             status: 500,
         };
     }
-    return { ok: true };
+    return outcome.verification !== undefined
+        ? { ok: true, verification: outcome.verification }
+        : { ok: true };
 }