@runuai/host 0.9.147 → 0.9.149

package/lib/agents/session-state.ts

@@ -0,0 +1,107 @@
+/**
+ * Durable agent-session state used by live roster reconciliation.
+ *
+ * The orchestrator normally owns a live AgentSession and closes it through the
+ * adapter. After a host restart, however, a removed agent can exist only as a
+ * host_agent_sessions row. These helpers stop that persisted runner
+ * without deleting its row or generation directory, and clear Codex's durable
+ * thread id when launch settings change.
+ */
+
+import { promises as fsp } from "node:fs";
+import { join } from "node:path";
+
+import { and, eq } from "drizzle-orm";
+
+import { getDb, schema } from "../db";
+import type { TaskEnvironmentHandle } from "../task-environment/types";
+import { isEnvironmentTransportProvider } from "../task-environment/types";
+import {
+  stopMachinePredecessorStrict,
+  type MachineSessionEnvironment,
+} from "./machine-durable";
+
+/** Durable-session ids persisted for one task, including rows marked closed.
+ * A crash can land after markClosed but before its stop reaches the runner. */
+export function persistedAgentIds(taskId: string): string[] {
+  return getDb()
+    .select({ agentId: schema.hostAgentSessions.agentId })
+    .from(schema.hostAgentSessions)
+    .where(eq(schema.hostAgentSessions.taskId, taskId))
+    .all()
+    .map((row) => row.agentId);
+}
+
+/**
+ * A changed model/engine/effort starts a fresh Codex thread. The channel
+ * transcript is the durable memory; resuming a thread created under the old
+ * launch settings can make the replacement keep using the old model.
+ */
+export function clearPersistedCodexThread(
+  taskId: string,
+  agentId: string,
+): void {
+  getDb()
+    .update(schema.hostAgentSessions)
+    .set({ codexThreadId: null, updatedAt: Date.now() })
+    .where(
+      and(
+        eq(schema.hostAgentSessions.taskId, taskId),
+        eq(schema.hostAgentSessions.agentId, agentId),
+      ),
+    )
+    .run();
+}
+
+/**
+ * Stop a persisted runner that has no in-memory AgentSession (boot recovery).
+ * The session directory and DB row deliberately remain for diagnostics.
+ */
+export async function stopPersistedAgentSession(
+  taskId: string,
+  agentId: string,
+  environment: TaskEnvironmentHandle<unknown>,
+): Promise<string | null> {
+  const db = getDb();
+  const row = db
+    .select()
+    .from(schema.hostAgentSessions)
+    .where(
+      and(
+        eq(schema.hostAgentSessions.taskId, taskId),
+        eq(schema.hostAgentSessions.agentId, agentId),
+      ),
+    )
+    .get();
+  if (!row) return null;
+
+  if (isEnvironmentTransportProvider(environment.descriptor.locator.provider)) {
+    await stopMachinePredecessorStrict(
+      environment as MachineSessionEnvironment,
+      row.sessionDir,
+    );
+  } else {
+    try {
+      await fsp.appendFile(
+        join(row.sessionDir, "inbox.jsonl"),
+        '{"__uai":"stop"}\n',
+      );
+    } catch (err) {
+      // A removed generation directory proves there is no runner left to read
+      // it. Permission, I/O, and other failures are not proof: retry them.
+      if ((err as NodeJS.ErrnoException).code !== "ENOENT") throw err;
+    }
+  }
+
+  db.update(schema.hostAgentSessions)
+    .set({ status: "closed", updatedAt: Date.now() })
+    .where(
+      and(
+        eq(schema.hostAgentSessions.taskId, taskId),
+        eq(schema.hostAgentSessions.agentId, agentId),
+        eq(schema.hostAgentSessions.sessionDir, row.sessionDir),
+      ),
+    )
+    .run();
+  return row.sessionDir;
+}

package/lib/agents/transport.ts

@@ -33,9 +33,9 @@ import {
 } from "node:fs";
 import { basename, dirname, join } from "node:path";
 
-import { and, eq } from "drizzle-orm";
+import { and, eq, isNull } from "drizzle-orm";
 
-import { getDb, schema } from "../db";
+import { getDb, schema, type Db } from "../db";
 import { taskWorkspaceDir } from "../env";
 import { machineSessionAuthorityEnv } from "../runtime-authority";
 import { requireContainerRuntimeOperational } from "../runtime-guard";
@@ -55,10 +55,14 @@ import {
   type ExitHandler,
   type LineHandler,
 } from "./proc";
+import { agentCliArgv } from "../agent-cli";
 import { isEnvironmentTransportProvider } from "../task-environment/types";
+import { attachCompatibilityKeysMatch } from "./attach-compatibility";
 
 /** The shared surface adapters program against (LineProcess's shape). */
 export interface LineTransport {
+  /** Exact durable row generation owned by this transport, when durable. */
+  readonly durableSessionDir?: string;
   onLine(handler: LineHandler): void;
   onExit(handler: ExitHandler): void;
   writeLine(value: unknown): void;
@@ -84,7 +88,7 @@ export interface AgentTransportOptions {
    * protocol state can't outlive the host process (codex handshake).
    */
   allowAttach: boolean;
-  /** Host-owned launch-policy generation. Both absent remains compatible. */
+  /** Host-owned launch-settings generation. Both absent remains compatible. */
   attachCompatibilityKey?: string;
   kind: string;
   debugLabel?: string;
@@ -120,6 +124,73 @@ function durableEnabled(): boolean {
   return process.env.UAI_DURABLE_SESSIONS !== "0";
 }
 
+/** Durable rows are keyed by task + agent for lookup, but callbacks belong to
+ * one exact generation. A delayed offset/exit from the predecessor must never
+ * mutate the replacement row after its upsert. */
+function durableRowCallbacks(
+  db: Db,
+  taskId: string,
+  agentId: string,
+  sessionDir: string,
+): {
+  persistOffset(offset: number): void;
+  markClosed(): void;
+} {
+  const ownedRow = () =>
+    and(
+      eq(schema.hostAgentSessions.taskId, taskId),
+      eq(schema.hostAgentSessions.agentId, agentId),
+      eq(schema.hostAgentSessions.sessionDir, sessionDir),
+    );
+  return {
+    persistOffset(offset: number): void {
+      db.update(schema.hostAgentSessions)
+        .set({ outboxOffset: offset, updatedAt: Date.now() })
+        .where(ownedRow())
+        .run();
+    },
+    markClosed(): void {
+      db.update(schema.hostAgentSessions)
+        .set({ status: "closed", updatedAt: Date.now() })
+        .where(ownedRow())
+        .run();
+    },
+  };
+}
+
+/** Claim a compatible durable row and promote a one-release legacy key to the
+ * rich launch fingerprint. The exact generation/key fence prevents a stale
+ * host process from rewriting a replacement row after reading its snapshot. */
+function claimCompatibleAttachRow(
+  db: Db,
+  taskId: string,
+  agentId: string,
+  sessionDir: string,
+  stored: string | null | undefined,
+  desired: string | null | undefined,
+): boolean {
+  if (!attachCompatibilityKeysMatch(stored, desired)) return false;
+  const storedKey = stored ?? null;
+  const desiredKey = desired ?? null;
+  if (storedKey === desiredKey) return true;
+  if (desiredKey === null) return false;
+  const result = db
+    .update(schema.hostAgentSessions)
+    .set({ attachCompatibilityKey: desiredKey, updatedAt: Date.now() })
+    .where(
+      and(
+        eq(schema.hostAgentSessions.taskId, taskId),
+        eq(schema.hostAgentSessions.agentId, agentId),
+        eq(schema.hostAgentSessions.sessionDir, sessionDir),
+        storedKey === null
+          ? isNull(schema.hostAgentSessions.attachCompatibilityKey)
+          : eq(schema.hostAgentSessions.attachCompatibilityKey, storedKey),
+      ),
+    )
+    .run();
+  return result.changes === 1;
+}
+
 export function createAgentTransport(opts: AgentTransportOptions): LineTransport {
   // ADR-121: machine-backed sessions ride the environment's own transport —
   // the container-runtime preflight is a docker/apple concern a machine task
@@ -161,29 +232,6 @@ export function createAgentTransport(opts: AgentTransportOptions): LineTransport
     )
     .get();
 
-  const persistOffset = (offset: number): void => {
-    db.update(schema.hostAgentSessions)
-      .set({ outboxOffset: offset, updatedAt: Date.now() })
-      .where(
-        and(
-          eq(schema.hostAgentSessions.taskId, opts.taskId),
-          eq(schema.hostAgentSessions.agentId, opts.agentId),
-        ),
-      )
-      .run();
-  };
-  const markClosed = (): void => {
-    db.update(schema.hostAgentSessions)
-      .set({ status: "closed", updatedAt: Date.now() })
-      .where(
-        and(
-          eq(schema.hostAgentSessions.taskId, opts.taskId),
-          eq(schema.hostAgentSessions.agentId, opts.agentId),
-        ),
-      )
-      .run();
-  };
-
   const tailKey = `${opts.taskId}:${opts.agentId}`;
 
   // ---- Attach: a previous host process left this agent's runner alive. ----
@@ -192,10 +240,23 @@ export function createAgentTransport(opts: AgentTransportOptions): LineTransport
     row &&
     row.status === "running" &&
     row.containerName === opts.environment.durableIdentity &&
-    (row.attachCompatibilityKey ?? null) ===
-      (opts.attachCompatibilityKey ?? null) &&
-    heartbeatFresh(row.sessionDir)
+    row.kind === opts.kind &&
+    heartbeatFresh(row.sessionDir) &&
+    claimCompatibleAttachRow(
+      db,
+      opts.taskId,
+      opts.agentId,
+      row.sessionDir,
+      row.attachCompatibilityKey,
+      opts.attachCompatibilityKey,
+    )
   ) {
+    const { persistOffset, markClosed } = durableRowCallbacks(
+      db,
+      opts.taskId,
+      opts.agentId,
+      row.sessionDir,
+    );
     const proc = new DurableProcess({
       hostSessionDir: row.sessionDir,
       initialOutboxOffset: row.outboxOffset,
@@ -240,6 +301,12 @@ export function createAgentTransport(opts: AgentTransportOptions): LineTransport
     opts.agentId,
     basename(sessionDir),
   );
+  const { persistOffset, markClosed } = durableRowCallbacks(
+    db,
+    opts.taskId,
+    opts.agentId,
+    sessionDir,
+  );
   const runnerInEnvironment = join(environmentSessionDir, "runner.mjs");
   try {
     copyFileSync(runnerScriptPath(), runnerInSession);
@@ -260,15 +327,16 @@ export function createAgentTransport(opts: AgentTransportOptions): LineTransport
     onCloseRequested: markClosed,
     debugLabel: opts.debugLabel,
     launch: async () => {
+      const cliArgv = agentCliArgv(opts.environment, [opts.cli, ...opts.cliArgs]);
       const result = await opts.environment.launchDetachedSession({
         argv: [
           "node",
           runnerInEnvironment,
           environmentSessionDir,
           "--",
-          opts.cli,
-          ...opts.cliArgs,
+          ...cliArgv,
         ],
+        projectEnvProfile: "task",
         inheritEnv: opts.passEnv ?? [],
         env: opts.explicitEnv ?? {},
         launchTimeoutMs: 30_000,
@@ -350,28 +418,6 @@ function machineDurableTransport(opts: AgentTransportOptions): LineTransport {
       ),
     )
     .get();
-  const persistOffset = (offset: number): void => {
-    db.update(schema.hostAgentSessions)
-      .set({ outboxOffset: offset, updatedAt: Date.now() })
-      .where(
-        and(
-          eq(schema.hostAgentSessions.taskId, opts.taskId),
-          eq(schema.hostAgentSessions.agentId, opts.agentId),
-        ),
-      )
-      .run();
-  };
-  const markClosed = (): void => {
-    db.update(schema.hostAgentSessions)
-      .set({ status: "closed", updatedAt: Date.now() })
-      .where(
-        and(
-          eq(schema.hostAgentSessions.taskId, opts.taskId),
-          eq(schema.hostAgentSessions.agentId, opts.agentId),
-        ),
-      )
-      .run();
-  };
   const tailKey = `${opts.taskId}:${opts.agentId}`;
 
   // ---- Attach: a previous host process left this machine's runner alive. --
@@ -382,9 +428,22 @@ function machineDurableTransport(opts: AgentTransportOptions): LineTransport {
     row &&
     row.status === "running" &&
     row.containerName === environment.durableIdentity &&
-    (row.attachCompatibilityKey ?? null) ===
-      (opts.attachCompatibilityKey ?? null)
+    row.kind === opts.kind &&
+    claimCompatibleAttachRow(
+      db,
+      opts.taskId,
+      opts.agentId,
+      row.sessionDir,
+      row.attachCompatibilityKey,
+      opts.attachCompatibilityKey,
+    )
   ) {
+    const { persistOffset, markClosed } = durableRowCallbacks(
+      db,
+      opts.taskId,
+      opts.agentId,
+      row.sessionDir,
+    );
     const proc = new MachineDurableProcess({
       environment,
       sessionDir: row.sessionDir,
@@ -406,6 +465,12 @@ function machineDurableTransport(opts: AgentTransportOptions): LineTransport {
     environment.descriptor.workspacePath,
     opts.agentId,
   );
+  const { persistOffset, markClosed } = durableRowCallbacks(
+    db,
+    opts.taskId,
+    opts.agentId,
+    sessionDir,
+  );
   const proc = new MachineDurableProcess({
     environment,
     sessionDir,
@@ -421,15 +486,16 @@ function machineDurableTransport(opts: AgentTransportOptions): LineTransport {
       }
       const runnerPath = await deployRunner(environment, sessionDir);
       await publishMachineCurrentSession(environment, sessionDir);
+      const cliArgv = agentCliArgv(environment, [opts.cli, ...opts.cliArgs]);
       const result = await environment.launchDetachedSession({
         argv: [
           "node",
           runnerPath,
           sessionDir,
           "--",
-          opts.cli,
-          ...opts.cliArgs,
+          ...cliArgv,
         ],
+        projectEnvProfile: "task",
         inheritEnv: opts.passEnv ?? [],
         env: opts.explicitEnv ?? {},
         launchTimeoutMs: 30_000,
@@ -475,7 +541,8 @@ function directEnvironmentTransport(opts: AgentTransportOptions): LineTransport
   return new EnvironmentLineProcess({
     environment: opts.environment,
     request: {
-      argv: [opts.cli, ...opts.cliArgs],
+      argv: agentCliArgv(opts.environment, [opts.cli, ...opts.cliArgs]),
+      projectEnvProfile: "task",
       inheritEnv: opts.passEnv ?? [],
       env: opts.explicitEnv ?? {},
       maxOutputBytes: AGENT_SESSION_OUTPUT_BUFFER_BYTES,

package/lib/agents/types.ts

@@ -180,9 +180,9 @@ export interface AgentSessionFactory {
     /** Host-derived restricted execution policy (ADR-083). Never supplied by
      *  the browser or stored on the roster entry. */
     executionProfile?: "communicator";
-    /** Durable runners are keyed by task+agent. A host-owned policy change
-     *  supplies a new key so restart recovery replaces, rather than attaches,
-     *  a process launched with incompatible argv/preamble/tooling. */
+    /** Durable runners are keyed by task+agent. Host-owned launch settings
+     *  supply a compatibility key so restart recovery replaces, rather than
+     *  attaches, a process launched with incompatible model/effort/policy. */
     attachCompatibilityKey?: string;
     /** ADR-048: extra per-agent process environment (e.g. this agent's own
      *  UAI_TASK_TOKEN so its `uai` CLI carries only its own permissions). */

package/lib/browser-testing.ts

@@ -1157,6 +1157,7 @@ export async function setupBrowserTesting(
     for (const step of VIEWER_STEPS) {
       if (environment) {
         await environment.launchDetachedSession({
+          projectEnvProfile: "maintenance",
           argv: ["sh", "-c", step],
           env: authorityEnv,
           maxOutputBytes: 64 * 1024,
@@ -1194,6 +1195,7 @@ export async function setupBrowserTesting(
     const installed = environment
       ? await (async () => {
           const chown = await environment.exec({
+            projectEnvProfile: "maintenance",
             argv: ["/usr/bin/chown", "node:node", "/opt/pw-browsers"],
             user: "root",
             env: authorityEnv,
@@ -1208,6 +1210,7 @@ export async function setupBrowserTesting(
             );
           }
           return environment.exec({
+            projectEnvProfile: "maintenance",
             argv: ["sh", "-lc", PREWARM_CMD],
             cwd: "/workspace",
             env: authorityEnv,
@@ -1309,6 +1312,7 @@ export async function setupBrowserTesting(
     ] as [string, ...string[]];
     const wrote = environment
       ? await environment.exec({
+          projectEnvProfile: "maintenance",
           argv: writeArgv,
           cwd: "/workspace",
           env: writeEnv,
@@ -1397,6 +1401,7 @@ export async function setupBrowserTesting(
       ] as [string, ...string[]];
       const registered = environment
         ? await environment.exec({
+            projectEnvProfile: "maintenance",
             argv: grokArgv,
             cwd: "/workspace",
             env: authorityEnv,
@@ -1469,6 +1474,7 @@ export async function setupBrowserTesting(
     };
     if (environment) {
       await environment.exec({
+        projectEnvProfile: "maintenance",
         argv: ["/bin/sh", "-c", guardedAptStart],
         user: "root",
         cwd: "/workspace",

package/lib/codex-auth.ts

@@ -261,6 +261,7 @@ export async function injectCodexIntoMachine(
   environment: {
     exec(request: {
       argv: readonly [string, ...string[]];
+      projectEnvProfile: "maintenance" | "task";
       timeoutMs: number;
       maxOutputBytes: number;
     }): Promise<{ exitCode: number | null; stderr: Uint8Array }>;
@@ -277,6 +278,7 @@ export async function injectCodexIntoMachine(
   if (!exists(join(dir, "auth.json"))) return true; // nothing to inject
   try {
     const made = await environment.exec({
+      projectEnvProfile: "maintenance",
       argv: ["/bin/mkdir", "-p", "/home/node/.codex"],
       timeoutMs: EXEC_TIMEOUT_MS,
       maxOutputBytes: 64 * 1024,

package/lib/credential-store.ts

@@ -36,12 +36,57 @@ export interface StoredParameter {
   value: string;
 }
 
+export interface StoredParameterVersion extends StoredParameter {
+  version: number;
+}
+
+export type ImmutableParameterPutResult = "created" | "matched";
+
+/** The immutable name exists, but its authenticated identity is different. */
+export class ImmutableParameterConflictError extends Error {
+  constructor(message = "immutable parameter identity conflicts with the existing value") {
+    super(message);
+    this.name = "ImmutableParameterConflictError";
+  }
+}
+
+/** A failed/ambiguous create could not yet be proved to be our prior write. */
+export class ImmutableParameterUnverifiedError extends Error {
+  constructor(message = "immutable parameter create could not be verified") {
+    super(message);
+    this.name = "ImmutableParameterUnverifiedError";
+  }
+}
+
 export interface CredentialStore {
   readonly kind: "aws-ssm";
   /** Create or overwrite one credential. Throws on failure. */
   put(name: string, value: string): Promise<void>;
+  /**
+   * Create one immutable SecureString with its identity tags in the same AWS
+   * request. A retry never overwrites or reads the value: metadata proves that
+   * an already-existing name is the exact prior write.
+   *
+   * Optional for custom/older stores. Callers that require create-once
+   * semantics must fail closed when it is absent.
+   */
+  putImmutable?(
+    name: string,
+    value: string,
+    tags: Record<string, string>,
+  ): Promise<ImmutableParameterPutResult>;
   /** The credential's plaintext, or null when it does not exist. */
   get(name: string): Promise<string | null>;
+  /**
+   * One exact immutable parameter version. Project-env replica migration
+   * uses this for legacy value references: reading the latest value and then
+   * assuming its version would allow a late old writer to substitute a new
+   * secret for the head the cloud actually named.
+   *
+   * Optional for older/custom stores. Callers that require a pinned read
+   * must fail closed when it is absent.
+   */
+  getVersion?(name: string, version: number): Promise<StoredParameterVersion | null>;
   /** Idempotent: a missing parameter is not an error. */
   delete(name: string): Promise<void>;
   /** Every credential under `path` (recursive), decrypted. Throws on failure. */
@@ -162,6 +207,19 @@ function isAccessDenied(result: CliResult): boolean {
   return /AccessDenied/.test(result.stderr);
 }
 
+function checkedTagEntries(tags: Record<string, string>): Array<[string, string]> {
+  const entries = Object.entries(tags);
+  for (const [key, value] of entries) {
+    if (
+      !/^[A-Za-z0-9_.:/=+@-]{1,128}$/.test(key) ||
+      !/^[A-Za-z0-9_.:/=+@ -]{0,256}$/.test(value)
+    ) {
+      throw new Error(`invalid tag ${key}`);
+    }
+  }
+  return entries;
+}
+
 /** Summarize a CLI failure WITHOUT echoing stdout (which could carry a value). */
 function failure(op: string, result: CliResult): Error {
   const line =
@@ -207,15 +265,59 @@ export class AwsSsmCredentialStore implements CredentialStore {
     if (result.status !== 0) throw failure("put-parameter", result);
   }
 
-  async tag(name: string, tags: Record<string, string>): Promise<void> {
+  async putImmutable(
+    name: string,
+    value: string,
+    tags: Record<string, string>,
+  ): Promise<ImmutableParameterPutResult> {
     if (!isParameterName(name)) throw new Error(`invalid parameter name: ${name}`);
-    const entries = Object.entries(tags);
-    if (entries.length === 0) return;
-    for (const [key, value] of entries) {
-      if (!/^[A-Za-z0-9_.:/=+@-]{1,128}$/.test(key) || !/^[A-Za-z0-9_.:/=+@ -]{0,256}$/.test(value)) {
-        throw new Error(`invalid tag ${key}`);
+    const entries = checkedTagEntries(tags);
+    if (entries.length === 0) {
+      throw new Error("immutable parameter identity tags are required");
+    }
+    const input = JSON.stringify({
+      Name: name,
+      Value: value,
+      Type: "SecureString",
+      KeyId: this.kmsKeyId,
+      Tier: "Advanced",
+      Overwrite: false,
+      Tags: entries.map(([Key, Value]) => ({ Key, Value })),
+    });
+    const result = await withPrivateInputFile(input, (path) =>
+      this.run(["ssm", "put-parameter", "--cli-input-json", `file://${path}`]),
+    );
+    if (result.status === 0) return "created";
+
+    // The CLI can lose the successful response, and a retry then receives
+    // ParameterAlreadyExists. The sign-in-box identity is intentionally
+    // write-only, so authenticate the prior write using metadata only.
+    let observed: Record<string, string>;
+    try {
+      observed = await this.listTags(name);
+    } catch {
+      throw new ImmutableParameterUnverifiedError();
+    }
+    let missing = false;
+    for (const [key, expected] of entries) {
+      const actual = observed[key];
+      if (actual === undefined) {
+        missing = true;
+      } else if (actual !== expected) {
+        throw new ImmutableParameterConflictError();
       }
     }
+    if (!missing) return "matched";
+
+    // Tags are eventually consistent with the create. Missing/partial tags
+    // are therefore retryable, never permission to add tags or overwrite.
+    throw new ImmutableParameterUnverifiedError();
+  }
+
+  async tag(name: string, tags: Record<string, string>): Promise<void> {
+    if (!isParameterName(name)) throw new Error(`invalid parameter name: ${name}`);
+    const entries = checkedTagEntries(tags);
+    if (entries.length === 0) return;
     const result = await this.run([
       "ssm",
       "add-tags-to-resource",
@@ -248,6 +350,39 @@ export class AwsSsmCredentialStore implements CredentialStore {
     return value;
   }
 
+  async getVersion(
+    name: string,
+    version: number,
+  ): Promise<StoredParameterVersion | null> {
+    if (!isParameterName(name)) throw new Error(`invalid parameter name: ${name}`);
+    if (!Number.isSafeInteger(version) || version < 1) {
+      throw new Error(`invalid parameter version: ${version}`);
+    }
+    const result = await this.run([
+      "ssm",
+      "get-parameter",
+      "--name",
+      `${name}:${version}`,
+      "--with-decryption",
+    ]);
+    if (result.status !== 0) {
+      if (isNotFound(result)) return null;
+      throw failure("get-parameter", result);
+    }
+    const parameter = (JSON.parse(result.stdout) as {
+      Parameter?: { Name?: unknown; Value?: unknown; Version?: unknown };
+    }).Parameter;
+    if (
+      parameter === undefined ||
+      parameter.Name !== name ||
+      typeof parameter.Value !== "string" ||
+      parameter.Version !== version
+    ) {
+      throw new Error("aws ssm get-parameter: malformed versioned response");
+    }
+    return { name, value: parameter.Value, version };
+  }
+
   async delete(name: string): Promise<void> {
     if (!isParameterName(name)) throw new Error(`invalid parameter name: ${name}`);
     const result = await this.run(["ssm", "delete-parameter", "--name", name]);

package/lib/engine-accounts.ts

@@ -654,6 +654,7 @@ async function copyDirIntoRaw(
   if (environment) {
     const run = async (argv: [string, ...string[]], step: string) => {
       const result = await environment.exec({
+        projectEnvProfile: "maintenance",
         argv,
         user: "root",
         env: RUNTIME_AUTHORITY_ENV,

package/lib/env-file.ts

@@ -133,6 +133,13 @@ export function restoreEnvFileSnapshotAtomic(
   }
 }
 
+/** Write `body` to `file` so a crash or power loss leaves either the old
+ *  file or the new one, never a torn or empty one: fsync the data, rename,
+ *  then fsync the directory. 0600, parent created 0700. */
+export function writeDurableFileAtomic(file: string, body: string): void {
+  replaceEnvFileAtomic(file, body);
+}
+
 function replaceEnvFileAtomic(file: string, body: string): void {
   const parent = dirname(file);
   mkdirSync(parent, { recursive: true, mode: 0o700 });