pi-session-mcp 0.12.0 → 0.13.0

package/dist/setup-cli.js

@@ -1,3 +1,4 @@
+import { cpusSchema, cpuSharesSchema, memorySchema } from "./writer-limits.js";
 import { WRITER_NAME_PATTERN } from "./writer-state.js";
 export function parseSetupArgs(argv) {
     let operation;
@@ -11,6 +12,7 @@ export function parseSetupArgs(argv) {
     let discard = false, codex = false, isolationControl = false;
     const container = {};
     const modeFlags = new Set();
+    const clearLimits = [];
     for (let index = 0; index < argv.length; index += 1) {
         const argument = argv[index];
         if (["--collect", "--reset", "--recreate", "--finish"].includes(argument)) {
@@ -81,7 +83,7 @@ export function parseSetupArgs(argv) {
             customizeSkill = value;
             continue;
         }
-        if (["--repo", "--mode", "--accept-host-writes", "--writers", "--lifecycle", "--profiles", "--image", "--network", "--cache", "--tags"].includes(argument)) {
+        if (["--repo", "--mode", "--accept-host-writes", "--writers", "--lifecycle", "--profiles", "--image", "--network", "--cache", "--tags", "--clean", "--cpus", "--cpu-shares", "--memory"].includes(argument)) {
             if (modeFlags.has(argument))
                 throw new Error("repo_argument_repeated");
             modeFlags.add(argument);
@@ -89,8 +91,8 @@ export function parseSetupArgs(argv) {
                 acceptHostWrites = true;
                 continue;
             }
-            const value = argv[++index];
-            if (!value || value.startsWith("-"))
+            const value = argv[++index] ?? "";
+            if ((!value || value.startsWith("-")) && !["--cpus", "--cpu-shares", "--memory"].includes(argument))
                 throw new Error("repo_argument_invalid");
             switch (argument) {
                 case "--repo":
@@ -129,8 +131,40 @@ export function parseSetupArgs(argv) {
                         throw new Error("tags_invalid");
                     container.tags = value;
                     break;
+                case "--clean":
+                    if (value !== "untracked" && value !== "all")
+                        throw new Error("clean_invalid");
+                    container.clean = value;
+                    break;
+                case "--cpus":
+                    if (value === "none") {
+                        clearLimits.push("cpus");
+                        break;
+                    }
+                    if (!value || !/^[0-9]+(?:\.[0-9]{1,2})?$/.test(value) || !cpusSchema.safeParse(Number(value)).success)
+                        throw new Error("cpus_invalid");
+                    container.cpus = Number(value);
+                    break;
+                case "--cpu-shares":
+                    if (value === "none") {
+                        clearLimits.push("cpuShares");
+                        break;
+                    }
+                    if (!value || !/^[0-9]+$/.test(value) || !cpuSharesSchema.safeParse(Number(value)).success)
+                        throw new Error("cpu_shares_invalid");
+                    container.cpuShares = Number(value);
+                    break;
+                case "--memory":
+                    if (value === "none") {
+                        clearLimits.push("memory");
+                        break;
+                    }
+                    if (!memorySchema.safeParse(value).success)
+                        throw new Error("memory_invalid");
+                    container.memory = value;
+                    break;
                 case "--cache":
-                    if (value !== "none" && value !== "go" && value !== "uv")
+                    if (value !== "none" && value !== "go" && value !== "uv" && value !== "npm")
                         throw new Error("cache_invalid");
                     container.cache = value;
                     break;
@@ -163,9 +197,9 @@ export function parseSetupArgs(argv) {
     if (modeFlags.size > 0) {
         if (repo === undefined || targets.length > 0 || customizeSkill !== undefined || (operation !== undefined && operation !== "dry-run" && operation !== "apply"))
             throw new Error("repo_combination");
-        if ((mode === "host" || mode === "read-only") && Object.keys(container).length > 0)
+        if ((mode === "host" || mode === "read-only") && (Object.keys(container).length > 0 || clearLimits.length > 0))
             throw new Error("repo_combination");
-        const request = { alias: repo, acceptHostWrites, apply: operation === "apply", discard, codex, ...(baseRef ? { baseRef } : {}), ...(mode === undefined ? {} : { mode }), ...(Object.keys(container).length === 0 ? {} : { container }) };
+        const request = { alias: repo, acceptHostWrites, apply: operation === "apply", discard, codex, ...(baseRef ? { baseRef } : {}), ...(mode === undefined ? {} : { mode }), ...(Object.keys(container).length === 0 ? {} : { container }), ...(clearLimits.length === 0 ? {} : { clearLimits }) };
         return { ...(operation === undefined ? {} : { operation }), targets, json, repo: request };
     }
     if (customizeSkill !== undefined) {

package/dist/setup-modes.d.ts

@@ -9,9 +9,12 @@ export interface ModeRequest {
     readonly discard?: boolean;
     readonly baseRef?: string;
     readonly codex?: boolean;
+    /** Limits to remove (`--cpus none` and so on); an omitted limit keeps the recorded one (#166). */
+    readonly clearLimits?: readonly ("cpus" | "cpuShares" | "memory")[];
 }
 /** A dry run writes nothing; apply serializes the entire read/validate/replace transaction. */
 export declare function changeExecutionMode(configPath: string, request: ModeRequest, dependencies?: {
+    cgroupControllers?: () => Promise<readonly string[]>;
     containerRuntime?: () => Promise<boolean>;
     beforeWrite?: (entry: import("./execution-modes.js").WorkspaceModeEntry) => Promise<SetupResult | undefined>;
     afterChange?: (output: SetupResult) => Promise<SetupResult>;

package/dist/setup-modes.js

@@ -1,3 +1,6 @@
+import { podmanCgroupControllers } from "./writer-boundary.js";
+import { createProcessRunner } from "./setup-process.js";
+import { writerLimits } from "./writer-limits.js";
 import { randomUUID } from "node:crypto";
 import { lstat, mkdir, open, readFile, rename, unlink } from "node:fs/promises";
 import { dirname, join } from "node:path";
@@ -65,7 +68,14 @@ export async function changeExecutionMode(configPath, request, dependencies = {}
             const previousBase = existing?.mode === "container" ? existing.base : undefined;
             const requestedBase = request.baseRef?.replace(/^refs\/heads\//, "");
             const base = requestedBase ?? previousBase ?? request.container?.base;
-            return { ...request.container, mode, ...(base === undefined ? {} : { base }) };
+            // Limits are outside the settings drift check, so an omitted flag must not drop one silently (#166).
+            const limits = Object.fromEntries(["cpus", "cpuShares", "memory"].flatMap((key) => {
+                if (request.clearLimits?.includes(key))
+                    return [];
+                const value = request.container?.[key] ?? (existing?.mode === "container" ? existing[key] : undefined);
+                return value === undefined ? [] : [[key, value]];
+            }));
+            return { ...request.container, ...limits, mode, ...(base === undefined ? {} : { base }) };
         })() : { mode };
         let proposed;
         try {
@@ -76,6 +86,13 @@ export async function changeExecutionMode(configPath, request, dependencies = {}
             return done("failed", "modes_file_invalid");
         }
         const resolved = resolveExecutionModes(proposed, aliases, config.executionProfiles).get(request.alias);
+        const limits = resolved.container && writerLimits(resolved.container);
+        if (limits) {
+            const controllers = await (dependencies.cgroupControllers ?? (() => podmanCgroupControllers(createProcessRunner())))().catch(() => []);
+            if (((limits.cpus !== undefined || limits.cpuShares !== undefined) && !controllers.includes("cpu"))
+                || (limits.memory !== undefined && !controllers.includes("memory")))
+                return done("failed", "cgroup_controller_unavailable");
+        }
         const refused = await dependencies.beforeWrite?.(resolved);
         if (refused)
             return refused;

package/dist/setup-writers.js

@@ -6,6 +6,7 @@ import { loadConfig } from "./config.js";
 import { containerRuntimeUsable } from "./container-runtime.js";
 import { ALIAS_PATTERN } from "./execution-profile.js";
 import { runDoctor } from "./doctor.js";
+import { MAX_WRITERS } from "./execution-modes.js";
 import { changeExecutionMode } from "./setup-modes.js";
 import { acquireOverrideLock, OverrideLockError } from "./override-lock.js";
 import { createCommandMcpStdioLauncher, createProcessRunner } from "./setup-process.js";
@@ -14,7 +15,8 @@ import { localHookNeededByOthers, ownsWakeHook, runWakeHook } from "./setup-hook
 import { result } from "./setup-result.js";
 import { createWriterRegistrationAdapter, unregisterWriter } from "./client-adapters/writer-registration.js";
 import { verifyMcpCapabilities } from "./client-adapters/mcp-verifier.js";
-import { IMAGE_PULL_TIMEOUT_MS } from "./writer-boundary.js";
+import { sameWriterLimits, writerLimits } from "./writer-limits.js";
+import { IMAGE_PULL_TIMEOUT_MS, podmanCgroupControllers } from "./writer-boundary.js";
 import { acquireWriterLease, WriterLeaseError } from "./writer-lease.js";
 import { ensureWriterAbsent } from "./writer-fence.js";
 import * as lifecycle from "./writer-lifecycle.js";
@@ -158,7 +160,7 @@ async function remove(ctx, name, discard, deps, extras = []) {
 const writerIndex = (name) => Number(name.slice(name.lastIndexOf("-w") + 2));
 async function plan(ctx, entry) {
     const keep = [], missing = [], surplus = [];
-    for (let index = 1; index <= 16; index++) {
+    for (let index = 1; index <= MAX_WRITERS; index++) {
         const name = writerName(ctx.alias, index), state = await readWriterState(ctx.home, name);
         if (entry.mode === "container" && index <= entry.container.writers) {
             keep.push(name);
@@ -208,6 +210,15 @@ async function reconcileUnlocked(configPath, alias, request, deps) {
                         add(name, drift);
                         return;
                     }
+                    const state = await readWriterState(ctx.home, name);
+                    if (!state)
+                        throw new Error("writer_state_invalid");
+                    const limits = writerLimits(entry.container);
+                    if (!sameWriterLimits(state.limits, limits)) {
+                        const { limits: _previous, ...rest } = state;
+                        await writeWriterState(ctx.home, name, { ...rest, ...(limits ? { limits } : {}) });
+                        add(name, { status: "ok", code: "writer_limits_updated" });
+                    }
                 }
                 // Decide for both clients before removing anything, so a divergent registration of one client never
                 // costs the writer its owned registration of the other. A client that is not installed has nothing to keep.
@@ -310,7 +321,7 @@ export async function changeWriterMode(configPath, request, deps) {
         return failed("alias_unknown");
     let runtimeProbe;
     const containerRuntime = () => runtimeProbe ??= (deps.containerRuntime ?? containerRuntimeUsable)().catch(() => false);
-    const modeDependencies = { containerRuntime };
+    const modeDependencies = { containerRuntime, cgroupControllers: () => podmanCgroupControllers(services(deps).runner) };
     try {
         let writerWork = request.mode === "container";
         if (!writerWork) {
@@ -322,7 +333,7 @@ export async function changeWriterMode(configPath, request, deps) {
                 return changeExecutionMode(configPath, request, modeDependencies);
             }
             writerWork = config.workspaceModes.get(request.alias)?.mode === "container";
-            for (let index = 1; index <= 16 && !writerWork; index++) {
+            for (let index = 1; index <= MAX_WRITERS && !writerWork; index++) {
                 try {
                     await lstat(join(writersRoot(deps.home ?? homedir()), writerName(request.alias, index)));
                     writerWork = true;
@@ -359,7 +370,7 @@ export async function changeWriterMode(configPath, request, deps) {
             const config = await loadConfig(configPath);
             if (!config.workspaceModes.get(request.alias)?.container?.base) {
                 const bases = new Set();
-                for (let index = 1; index <= 16; index++) {
+                for (let index = 1; index <= MAX_WRITERS; index++) {
                     const state = await readWriterState(deps.home ?? homedir(), writerName(request.alias, index));
                     if (state)
                         bases.add(state.base.ref);
@@ -398,6 +409,24 @@ export async function changeWriterMode(configPath, request, deps) {
                                 throw error;
                             }
                         }
+                        // Settings drift before the write, so a kept writer with changed settings refuses the mode
+                        // change itself and the modes file never records a mode no writer matches (#163). Read-only like
+                        // the dry run, which fences nothing; reconcile re-checks under its fence. Missing writers have
+                        // no settings yet.
+                        if (entry.mode === "container") {
+                            const { life } = services(deps);
+                            const rawConfig = JSON.parse(await readFile(configPath, "utf8")), overrideDirectory = skillOverrideDirectory(configPath);
+                            const drifted = [];
+                            for (const name of planned.keep) {
+                                if (planned.missing.includes(name))
+                                    continue;
+                                const drift = await life.writerSettingsDrift(ctx, { index: writerIndex(name), settings: entry.container, rawConfig, overrideDirectory });
+                                if (drift)
+                                    drifted.push({ target: targetFor(request.alias, name), ...drift });
+                            }
+                            if (drifted.length)
+                                return result(operation, drifted);
+                        }
                     }
                     else
                         await preflight(ctx, planned.surplus, request.discard ?? false, deps);
@@ -419,7 +448,9 @@ export async function changeWriterMode(configPath, request, deps) {
                         for (const name of planned.keep) {
                             // The same settings check as apply, so a drifted writer shows before anything is applied (#134).
                             const drift = await life.writerSettingsDrift(ctx, { index: writerIndex(name), settings: proposed.container, rawConfig, overrideDirectory });
-                            kept.push({ target: targetFor(request.alias, name), ...(drift ?? { status: "planned", code: "writer_planned" }) });
+                            const state = await readWriterState(ctx.home, name);
+                            const updatingLimits = state && state.phase !== "provisioning" && !sameWriterLimits(state.limits, writerLimits(proposed.container));
+                            kept.push({ target: targetFor(request.alias, name), ...(drift ?? { status: "planned", code: updatingLimits ? "writer_limits_update_planned" : "writer_planned" }) });
                         }
                         const refused = kept.some((finding) => finding.status === "failed" || finding.status === "divergent");
                         writers = result("dry-run", [...kept, ...planned.surplus.map((name) => ({ target: targetFor(request.alias, name), status: "planned", code: "writer_remove_planned" }))], refused ? "failed" : "planned");

package/dist/tool-schemas.d.ts

@@ -334,6 +334,10 @@ export declare const capabilitiesSchema: z.ZodObject<{
         }>;
         extensions: z.ZodArray<z.ZodString>;
         grantedExtensionTools: z.ZodArray<z.ZodString>;
+        shell: z.ZodEnum<{
+            none: "none";
+            sandboxed: "sandboxed";
+        }>;
         skills: z.ZodArray<z.ZodString>;
     }, z.core.$strict>>;
 }, z.core.$strict>;

package/dist/tool-schemas.js

@@ -44,6 +44,7 @@ export const capabilitiesSchema = z.object({
         thinkingLevel: thinkingLevelSchema,
         extensions: z.array(z.string()),
         grantedExtensionTools: z.array(z.string()),
+        shell: z.enum(["none", "sandboxed"]),
         skills: z.array(aliasSchema),
     }).strict()),
 }).strict();

package/dist/writer-boundary.d.ts

@@ -46,6 +46,8 @@ export declare function podmanInfo(runner: CommandRunner): Promise<{
     usable: boolean;
     version?: string;
 }>;
+/** A failed or malformed host probe provides no usable controllers. */
+export declare function podmanCgroupControllers(runner: CommandRunner): Promise<readonly string[]>;
 export declare function resolveImage(runner: CommandRunner, image: string, pull: boolean): Promise<string>;
 export declare function verifyCloneLayout(clone: string): Promise<void>;
 export declare function isSafeRefName(name: string): boolean;

package/dist/writer-boundary.js

@@ -35,6 +35,12 @@ export function serveArgs(paths, state, command, releaseRoot, eventsDir, options
         "-e", "PI_CODING_AGENT_DIR=/pi/agent",
         "-e", "PI_SESSION_MCP_WRITER_GUARD=/pi/config/writer-guard.json",
     ];
+    if (state.limits?.cpus !== undefined)
+        args.push(`--cpus=${state.limits.cpus}`);
+    if (state.limits?.cpuShares !== undefined)
+        args.push(`--cpu-shares=${state.limits.cpuShares}`);
+    if (state.limits?.memory !== undefined)
+        args.push(`--memory=${state.limits.memory}`);
     if (options?.name !== undefined)
         args.push("--name", writerContainerName(options.name));
     if (eventsDir !== undefined)
@@ -43,6 +49,8 @@ export function serveArgs(paths, state, command, releaseRoot, eventsDir, options
         args.push("-v", `${paths.go}:/pi/go:rw`, "-e", "GOPATH=/pi/go", "-e", "GOCACHE=/pi/go/cache", "-e", "GOTOOLCHAIN=local");
     if (state.cache === "uv")
         args.push("-v", `${paths.uv}:/pi/uv:rw`, "-e", "UV_CACHE_DIR=/pi/uv/cache", "-e", "npm_config_cache=/pi/uv/npm");
+    if (state.cache === "npm")
+        args.push("-v", `${paths.npm}:/pi/npm:rw`, "-e", "npm_config_cache=/pi/npm/cache");
     return [...args, state.imageId, ...command];
 }
 export class EventsDirectoryError extends Error {
@@ -261,6 +269,25 @@ export async function podmanInfo(runner) {
         return { usable: false };
     }
 }
+/** A failed or malformed host probe provides no usable controllers. */
+export async function podmanCgroupControllers(runner) {
+    try {
+        const output = await podman(runner, ["info", "--format", "json"]);
+        if (output.exitCode !== 0)
+            return [];
+        const info = JSON.parse(output.stdout);
+        if (!info || typeof info !== "object" || !("host" in info))
+            return [];
+        const host = info.host;
+        if (!host || typeof host !== "object" || !("cgroupControllers" in host))
+            return [];
+        const controllers = host.cgroupControllers;
+        return Array.isArray(controllers) && controllers.every((value) => typeof value === "string") ? controllers : [];
+    }
+    catch {
+        return [];
+    }
+}
 export async function resolveImage(runner, image, pull) {
     if (image !== "node" && !/^[0-9a-f]{64}$/.test(image))
         throw new BoundaryError("image_unavailable");

package/dist/writer-lifecycle.d.ts

@@ -35,6 +35,7 @@ export declare function renderContainedConfig(alias: string, clonePath: string,
         mcpServers?: Readonly<Record<string, import("./mcp-config.js").McpServerConfig>> | undefined;
         extensions?: string[] | undefined;
         grantedExtensionTools?: string[] | undefined;
+        shell?: "sandboxed" | undefined;
         skills?: string[] | undefined;
     }>;
 };

package/dist/writer-lifecycle.js

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import { constants } from "node:fs";
 import { chmod, mkdir, open, readdir, rm, writeFile } from "node:fs/promises";
 import { basename, join } from "node:path";
+import { writerLimits } from "./writer-limits.js";
 import { configSchema } from "./config.js";
 import { renderWrapper } from "./writer-wrapper.js";
 import { builtinSkillName } from "./skill-catalog.js";
@@ -220,7 +221,7 @@ async function storedConfig(paths) {
 async function sameSettings(paths, existing, settings, now) {
     const stored = await storedConfig(paths);
     return stored !== undefined && existing.imageId === now.imageId && existing.lifecycle === settings.lifecycle
-        && existing.network === settings.network && existing.cache === settings.cache && existing.tags === settings.tags
+        && existing.network === settings.network && existing.cache === settings.cache && existing.tags === settings.tags && existing.clean === settings.clean
         && JSON.stringify(existing.profiles) === JSON.stringify(settings.profiles)
         && JSON.stringify(existing.providers) === JSON.stringify(now.providers) && canonical(withoutDeliveryOff(stored)) === canonical(withoutDeliveryOff(now.config));
 }
@@ -295,12 +296,13 @@ export async function provisionWriter(ctx, input) {
         // With spool delivery the spool directory exists from provisioning on: launch would otherwise add it to the
         // writer root, a host directory the acceptance harness digests around its own first launch.
         const spool = config.events?.delivery === "spool" ? [paths.events] : [];
-        const cache = settings.cache === "go" ? [paths.go] : settings.cache === "uv" ? [paths.uv] : [];
+        const cache = settings.cache === "none" ? [] : [paths[settings.cache]];
         for (const path of [paths.root, paths.clone, paths.config, paths.agent, paths.bundles, ...spool, ...cache])
             await privateDirectory(path);
         const state = {
             schemaVersion: 1, alias: ctx.alias, index, phase: "provisioning", lifecycle: settings.lifecycle,
-            profiles: [...settings.profiles], providers, network: settings.network, cache: settings.cache, tags: settings.tags, imageId,
+            profiles: [...settings.profiles], providers, network: settings.network, cache: settings.cache, tags: settings.tags, clean: settings.clean, imageId,
+            ...(writerLimits(settings) ? { limits: writerLimits(settings) } : {}),
             base: { ref: `refs/heads/${short}`, commit },
         };
         await writeWriterState(ctx.home, name, state);
@@ -511,7 +513,7 @@ ${BOUNDARY_GIT} for-each-ref --format='%(refname)' refs/heads | while read -r re
   if [ "$ref" != "refs/heads/$2" ]; then ${BOUNDARY_GIT} update-ref -d "$ref"; fi
 done
 ${BOUNDARY_GIT} stash clear
-${BOUNDARY_GIT} clean -fd
+${BOUNDARY_GIT} clean ${state.clean === "all" ? "-ffdx" : "-fd"}
 ${identityScript(4, 5)}`;
         const result = await ctx.runner.run("podman", throwawayArgs(name, paths, state.imageId, { clone: "rw", bundles: true }, script, [base.ref, base.short, base.commit, ...await operatorIdentity(ctx)]), AbortSignal.timeout(IMAGE_PULL_TIMEOUT_MS));
         if (result.exitCode !== 0)

package/dist/writer-limits.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export declare const cpusSchema: z.ZodNumber;
+export declare const cpuSharesSchema: z.ZodNumber;
+export declare const memorySchema: z.ZodString;
+export declare const writerLimitsSchema: z.ZodObject<{
+    cpus: z.ZodOptional<z.ZodNumber>;
+    cpuShares: z.ZodOptional<z.ZodNumber>;
+    memory: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type WriterLimits = z.infer<typeof writerLimitsSchema>;
+/** Omitted settings remove previous limits; never persist an empty limits object. */
+export declare function writerLimits(settings: WriterLimits): WriterLimits | undefined;
+export declare function sameWriterLimits(left: WriterLimits | undefined, right: WriterLimits | undefined): boolean;

package/dist/writer-limits.js

@@ -0,0 +1,19 @@
+import { z } from "zod";
+export const cpusSchema = z.number().positive().max(1024).multipleOf(0.01);
+export const cpuSharesSchema = z.number().int().min(2).max(262144);
+export const memorySchema = z.string().regex(/^[1-9][0-9]{0,6}[mg]$/);
+export const writerLimitsSchema = z.object({
+    cpus: cpusSchema.optional(),
+    cpuShares: cpuSharesSchema.optional(),
+    memory: memorySchema.optional(),
+}).strict();
+/** Omitted settings remove previous limits; never persist an empty limits object. */
+export function writerLimits(settings) {
+    const { cpus, cpuShares, memory } = settings;
+    if (cpus === undefined && cpuShares === undefined && memory === undefined)
+        return undefined;
+    return { ...(cpus === undefined ? {} : { cpus }), ...(cpuShares === undefined ? {} : { cpuShares }), ...(memory === undefined ? {} : { memory }) };
+}
+export function sameWriterLimits(left, right) {
+    return left?.cpus === right?.cpus && left?.cpuShares === right?.cpuShares && left?.memory === right?.memory;
+}

package/dist/writer-relay.js

@@ -69,7 +69,7 @@ const creationCodes = new Set([
     "model_unavailable", "thinking_level_unavailable", "execution_selection_mismatch", "external_mcp_unavailable",
     "external_mcp_no_tools", "external_mcp_grant_tool_missing", "external_mcp_activation_mismatch",
     "extension_not_installed", "extension_version_mismatch", "extension_load_failed", "extension_tool_conflict",
-    "extension_tool_missing", "skill_load_failed", "pi_session_creation_failed",
+    "extension_tool_missing", "skill_load_failed", "sandbox_unavailable", "pi_session_creation_failed",
 ]);
 class InnerError extends Error {
     code;

package/dist/writer-state.d.ts

@@ -33,12 +33,22 @@ export declare const writerStateSchema: z.ZodObject<{
     cache: z.ZodEnum<{
         go: "go";
         none: "none";
+        npm: "npm";
         uv: "uv";
     }>;
     tags: z.ZodDefault<z.ZodEnum<{
         none: "none";
         reachable: "reachable";
     }>>;
+    clean: z.ZodDefault<z.ZodEnum<{
+        all: "all";
+        untracked: "untracked";
+    }>>;
+    limits: z.ZodOptional<z.ZodObject<{
+        cpus: z.ZodOptional<z.ZodNumber>;
+        cpuShares: z.ZodOptional<z.ZodNumber>;
+        memory: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
     imageId: z.ZodString;
     base: z.ZodObject<{
         ref: z.ZodString;
@@ -73,6 +83,7 @@ export declare function writerPaths(home: string, name: string): {
     events: string;
     go: string;
     uv: string;
+    npm: string;
     wrapper: string;
     state: string;
     acceptanceFailure: string;

package/dist/writer-state.js

@@ -5,6 +5,7 @@ import { lstat, mkdir, open, readFile, rename, unlink } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { z } from "zod";
 import { PACKAGE_VERSION } from "./package-metadata.js";
+import { writerLimitsSchema } from "./writer-limits.js";
 import { ALIAS_PATTERN } from "./execution-profile.js";
 export const WRITER_NAME_PATTERN = /^[a-z][a-z0-9_-]{0,63}-w([1-9]|1[0-6])$/;
 export class WriterStateError extends Error {
@@ -31,8 +32,10 @@ export const writerStateSchema = z.object({
         model: z.string().min(1).max(200),
     }).strict()).refine((providers) => new Set(providers.map(({ provider }) => provider)).size === providers.length).readonly(),
     network: z.enum(["pasta", "none"]),
-    cache: z.enum(["none", "go", "uv"]),
+    cache: z.enum(["none", "go", "uv", "npm"]),
     tags: z.enum(["none", "reachable"]).default("none"),
+    clean: z.enum(["untracked", "all"]).default("untracked"),
+    limits: writerLimitsSchema.optional(),
     imageId: hex64,
     base: z.object({ ref: z.string(), commit: z.string().regex(/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/) }).strict(),
     acceptance: z.object({
@@ -62,7 +65,7 @@ export function writerPaths(home, name) {
     const root = join(writersRoot(home), name);
     return {
         root, clone: join(root, "clone"), agent: join(root, "agent"), bundles: join(root, "bundles"),
-        config: join(root, "config"), events: join(root, "events"), go: join(root, "go"), uv: join(root, "uv"), wrapper: join(root, "wrapper.sh"), state: join(root, "state.json"),
+        config: join(root, "config"), events: join(root, "events"), go: join(root, "go"), uv: join(root, "uv"), npm: join(root, "npm"), wrapper: join(root, "wrapper.sh"), state: join(root, "state.json"),
         acceptanceFailure: join(root, "acceptance-failure.json"),
     };
 }