@ai-sdk/harness-pi 1.0.93 → 1.0.95

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/harness-pi",
-  "version": "1.0.93",
+  "version": "1.0.95",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -26,10 +26,10 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/harness": "1.0.91",
-    "@ai-sdk/provider-utils": "5.0.32",
+    "@ai-sdk/harness": "1.0.93",
+    "@ai-sdk/provider-utils": "5.0.33",
     "@earendil-works/pi-ai": "0.74.2",
-    "@earendil-works/pi-coding-agent": "^0.80.10",
+    "@earendil-works/pi-coding-agent": "^0.84.3",
     "pi-mcp-adapter": "2.12.1",
     "typebox": "^1.1.38"
   },
@@ -37,7 +37,7 @@
     "zod": "^3.25.76 || ^4.1.8"
   },
   "devDependencies": {
-    "@ai-sdk/sandbox-just-bash": "1.0.91",
+    "@ai-sdk/sandbox-just-bash": "1.0.93",
     "@types/node": "22.19.19",
     "@vercel/ai-tsconfig": "0.0.0",
     "tsup": "^8.5.1",

package/src/index.ts

@@ -9,4 +9,4 @@ export const pi = createPi();
 export { createPi } from './pi-harness';
 export { VERSION } from './version';
 export type { PiHarnessSettings } from './pi-harness';
-export type { PiAuthenticationMode, PiAuthOptions } from './pi-auth';
+export type { PiAuthenticationMode } from './pi-auth';

package/src/pi-auth.ts

@@ -1,51 +1,175 @@
-import type {
-  ModelRegistry,
+import {
   ModelRuntime,
+  type CreateModelRuntimeOptions,
+  type ModelRegistry,
 } from '@earendil-works/pi-coding-agent';
-import { getAiGatewayAuthFromEnv } from '@ai-sdk/harness/utils';
+import type { HarnessV1Authentication } from '@ai-sdk/harness';
+import {
+  getAiGatewayAuthFromEnv,
+  isHarnessAuthenticationEnvironment,
+} from '@ai-sdk/harness/utils';
+import { access } from 'node:fs/promises';
 import { VERSION } from './version';
 
 type ProviderConfigInput = Parameters<ModelRegistry['registerProvider']>[1];
+type PiCredentialStore = NonNullable<CreateModelRuntimeOptions['credentials']>;
+type PiCredential = Exclude<
+  Awaited<ReturnType<PiCredentialStore['read']>>,
+  undefined
+>;
+type PiModelRuntimeInternals = {
+  models: {
+    authContext: {
+      env(name: string): Promise<string | undefined>;
+      fileExists(path: string): Promise<boolean>;
+    };
+  };
+};
+type PiMutableProvider = {
+  auth: ReturnType<ModelRuntime['getProviders']>[number]['auth'];
+};
 
 /**
  * Pi auth options. Choose an explicit mode or rely on 'auto' (precedence:
  * explicit gateway, then OpenAI / Anthropic / custom environment variables).
  */
-export type PiAuthenticationMode =
-  | 'auto'
-  | 'openai'
-  | 'anthropic'
-  | 'custom'
-  | 'ai-gateway';
-
-/**
- * @deprecated Passing an object to auth options is deprecated. Use a `PiAuthenticationMode` string value ("auto" | "openai" | "anthropic" | "custom" | "ai-gateway") instead, and pass credentials via environment variables.
- */
-export type LegacyPiAuthOptions = {
-  readonly gateway?: {
-    readonly apiKey?: string;
-    readonly baseUrl?: string;
-  };
-  /**
-   * Resolved environment-variable pairs of the form `<PREFIX>_API_KEY` and
-   * (optionally) `<PREFIX>_BASE_URL`. Special-cased prefixes:
-   *  - `AI_GATEWAY` → registers `vercel-ai-gateway`
-   *  - `OPENAI`     → registers `openai`
-   *  - `ANTHROPIC`  → registers `anthropic` (`ANTHROPIC_AUTH_TOKEN` adds a
-   *                   bearer auth header)
-   * Any other `<PREFIX>_API_KEY` with a matching `<PREFIX>_BASE_URL` is
-   * registered as the lowercased, dash-separated prefix.
-   */
-  readonly customEnv?: Record<string, string>;
-};
-
-export type PiAuthOptions = PiAuthenticationMode | LegacyPiAuthOptions;
+export type PiAuthenticationMode = HarnessV1Authentication<
+  'openai' | 'anthropic' | 'custom'
+>;
 
 const DEFAULT_GATEWAY_BASE_URL = 'https://ai-gateway.vercel.sh';
 const DEFAULT_OPENAI_BASE_URL = 'https://api.openai.com/v1';
 const DEFAULT_ANTHROPIC_BASE_URL = 'https://api.anthropic.com';
 const HARNESS_CLIENT_APP = `ai-sdk/harness-pi/${VERSION}`;
 
+function createIsolatedPiCredentialStore(): {
+  credentials: PiCredentialStore;
+  finishInitialization(): void;
+} {
+  let initializing = true;
+  const bootstrapEnvironment = new Proxy<Record<string, string>>(
+    {},
+    {
+      get: (_target, property) =>
+        typeof property === 'string'
+          ? 'harness-pi-authentication-bootstrap'
+          : undefined,
+    },
+  );
+  const bootstrapCredential = {
+    type: 'api_key',
+    key: 'harness-pi-authentication-bootstrap',
+    env: bootstrapEnvironment,
+  } satisfies PiCredential;
+  const credentials: PiCredentialStore = {
+    async read() {
+      return initializing ? bootstrapCredential : undefined;
+    },
+    async list() {
+      return [];
+    },
+    async modify(..._input: Parameters<PiCredentialStore['modify']>) {
+      return undefined;
+    },
+    async delete() {},
+  };
+
+  return {
+    credentials,
+    finishInitialization() {
+      initializing = false;
+    },
+  };
+}
+
+function scopePiProviderEnvironment({
+  modelRuntime,
+  authenticationEnvironment,
+}: {
+  modelRuntime: ModelRuntime;
+  authenticationEnvironment: Record<string, string>;
+}): void {
+  for (const provider of modelRuntime.getProviders()) {
+    const apiKeyAuthentication = provider.auth.apiKey;
+    if (!apiKeyAuthentication) continue;
+
+    (provider as unknown as PiMutableProvider).auth = {
+      ...provider.auth,
+      apiKey: {
+        ...apiKeyAuthentication,
+        resolve: async input => {
+          const result = await apiKeyAuthentication.resolve(input);
+          return result
+            ? {
+                ...result,
+                env: {
+                  ...authenticationEnvironment,
+                  ...result.env,
+                },
+              }
+            : undefined;
+        },
+      },
+    };
+  }
+}
+
+export async function createPiModelRuntime({
+  auth,
+  authPath,
+  modelsPath,
+}: {
+  auth: PiAuthenticationMode | undefined;
+  authPath: string;
+  modelsPath: string;
+}): Promise<ModelRuntime> {
+  if (!isHarnessAuthenticationEnvironment(auth)) {
+    return ModelRuntime.create({
+      authPath,
+      modelsPath,
+      allowModelNetwork: false,
+    });
+  }
+
+  const isolatedCredentials = createIsolatedPiCredentialStore();
+  const modelRuntime = await ModelRuntime.create({
+    credentials: isolatedCredentials.credentials,
+    modelsPath: null,
+    allowModelNetwork: false,
+  });
+
+  /*
+   * ModelRuntime creates its internal model collection with a process-backed
+   * authentication context and does not expose an authentication-context
+   * option. The bootstrap credential prevents construction-time provider
+   * checks from consulting that context. Once constructed, authentication is
+   * scoped to the supplied record and availability is recomputed with an
+   * empty in-memory credential store.
+   */
+  (modelRuntime as unknown as PiModelRuntimeInternals).models.authContext = {
+    async env(name) {
+      return auth[name];
+    },
+    async fileExists(filePath) {
+      if (filePath !== auth.GOOGLE_APPLICATION_CREDENTIALS) return false;
+      try {
+        await access(filePath);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+  };
+  scopePiProviderEnvironment({
+    modelRuntime,
+    authenticationEnvironment: auth,
+  });
+  isolatedCredentials.finishInitialization();
+  await modelRuntime.refresh({ allowNetwork: false });
+
+  return modelRuntime;
+}
+
 function createGatewayProviderConfig({
   apiKey,
   baseUrl,
@@ -86,68 +210,54 @@ async function register({
   await registries.modelRuntime.setRuntimeApiKey(provider, apiKey);
 }
 
-function hasConfiguredValue(value: unknown): boolean {
-  if (value == null) return false;
-  if (typeof value === 'string') return value.length > 0;
-  if (typeof value !== 'object') return true;
-  return Object.values(value).some(hasConfiguredValue);
-}
-
 export function resolvePiEnv({
   options,
   env,
 }: {
-  options: PiAuthOptions | undefined;
+  options: PiAuthenticationMode | undefined;
   env: NodeJS.ProcessEnv;
 }): Record<string, string> {
-  const normalizedOptions = normalizePiAuthToLegacyAuth(options);
-  const customEnvConfigured = hasConfiguredValue(normalizedOptions?.customEnv);
-  if (customEnvConfigured) {
-    return resolveCustomEnv({ customEnv: normalizedOptions!.customEnv ?? {} });
-  }
-
-  const gatewayConfigured = hasConfiguredValue(normalizedOptions?.gateway);
-  const gatewayAuthFromEnv = getAiGatewayAuthFromEnv({ env });
-  if (gatewayConfigured) {
-    const apiKey =
-      normalizedOptions!.gateway?.apiKey ?? gatewayAuthFromEnv.apiKey;
-    const baseUrl =
-      normalizedOptions!.gateway?.baseUrl ?? gatewayAuthFromEnv.baseUrl;
-    if (apiKey) {
-      return { AI_GATEWAY_API_KEY: apiKey, AI_GATEWAY_BASE_URL: baseUrl };
-    }
-    return {};
-  }
+  const suppliedEnvironment = isHarnessAuthenticationEnvironment(options);
+  const authenticationEnvironment = suppliedEnvironment ? options : env;
+  const gatewayAuthFromEnv = getAiGatewayAuthFromEnv({
+    env: authenticationEnvironment,
+  });
 
   // Handle explicit string modes with process env
   if (typeof options === 'string') {
     switch (options) {
       case 'openai':
-        if (env.OPENAI_API_KEY) {
+        if (authenticationEnvironment.OPENAI_API_KEY) {
           return {
-            OPENAI_API_KEY: env.OPENAI_API_KEY,
-            ...(env.OPENAI_BASE_URL
-              ? { OPENAI_BASE_URL: env.OPENAI_BASE_URL }
+            OPENAI_API_KEY: authenticationEnvironment.OPENAI_API_KEY,
+            ...(authenticationEnvironment.OPENAI_BASE_URL
+              ? { OPENAI_BASE_URL: authenticationEnvironment.OPENAI_BASE_URL }
               : {}),
           };
         }
         return {};
       case 'anthropic':
-        if (env.ANTHROPIC_API_KEY) {
+        if (authenticationEnvironment.ANTHROPIC_API_KEY) {
           return {
-            ANTHROPIC_API_KEY: env.ANTHROPIC_API_KEY,
-            ...(env.ANTHROPIC_BASE_URL
-              ? { ANTHROPIC_BASE_URL: env.ANTHROPIC_BASE_URL }
+            ANTHROPIC_API_KEY: authenticationEnvironment.ANTHROPIC_API_KEY,
+            ...(authenticationEnvironment.ANTHROPIC_BASE_URL
+              ? {
+                  ANTHROPIC_BASE_URL:
+                    authenticationEnvironment.ANTHROPIC_BASE_URL,
+                }
               : {}),
-            ...(env.ANTHROPIC_AUTH_TOKEN
-              ? { ANTHROPIC_AUTH_TOKEN: env.ANTHROPIC_AUTH_TOKEN }
+            ...(authenticationEnvironment.ANTHROPIC_AUTH_TOKEN
+              ? {
+                  ANTHROPIC_AUTH_TOKEN:
+                    authenticationEnvironment.ANTHROPIC_AUTH_TOKEN,
+                }
               : {}),
           };
         }
         return {};
       case 'custom': {
         const result: Record<string, string> = {};
-        for (const [key, value] of Object.entries(env)) {
+        for (const [key, value] of Object.entries(authenticationEnvironment)) {
           if (
             value &&
             (key.endsWith('_API_KEY') ||
@@ -183,7 +293,7 @@ export function resolvePiEnv({
 
   // 'auto' fallback: pick up any other provider credentials from the env.
   const ambient: Record<string, string> = {};
-  for (const [key, value] of Object.entries(env)) {
+  for (const [key, value] of Object.entries(authenticationEnvironment)) {
     if (
       value &&
       (key.endsWith('_API_KEY') ||
@@ -202,32 +312,20 @@ export async function registerPiProviders({
   registries,
   clientApp = HARNESS_CLIENT_APP,
 }: {
-  options: PiAuthOptions | undefined;
+  options: PiAuthenticationMode | undefined;
   resolvedEnv: Record<string, string>;
   registries: PiRegistries;
   clientApp?: string;
 }): Promise<void> {
-  const normalizedOptions = normalizePiAuthToLegacyAuth(options);
-  if (hasConfiguredValue(normalizedOptions?.customEnv)) {
-    await registerCustomProviders({
-      customEnv: normalizedOptions!.customEnv ?? {},
-      registries,
-      clientApp,
-    });
-    return;
-  }
-
-  // Legacy customEnv was handled above. Everything else reduces to a mode:
-  // string modes pass through, `undefined` is 'auto', and legacy gateway
-  // objects fall through to the trailing gateway-registration block.
-  const mode =
-    typeof options === 'string' ? options : options == null ? 'auto' : 'legacy';
+  const suppliedEnvironment = isHarnessAuthenticationEnvironment(options);
+  const authenticationEnvironment = suppliedEnvironment ? options : process.env;
+  const mode = typeof options === 'string' ? options : 'auto';
 
   switch (mode) {
     case 'openai': {
       const env = pickOpenAIEnv(resolvedEnv);
       await registerCustomProviders({
-        customEnv: { ...pickOpenAIEnv(process.env), ...env },
+        customEnv: { ...pickOpenAIEnv(authenticationEnvironment), ...env },
         registries,
         clientApp,
       });
@@ -236,7 +334,7 @@ export async function registerPiProviders({
     case 'anthropic': {
       const env = pickAnthropicEnv(resolvedEnv);
       await registerCustomProviders({
-        customEnv: { ...pickAnthropicEnv(process.env), ...env },
+        customEnv: { ...pickAnthropicEnv(authenticationEnvironment), ...env },
         registries,
         clientApp,
       });
@@ -246,14 +344,16 @@ export async function registerPiProviders({
       // 'custom' registers every provider with credentials in the env.
       const env = pickProviderEnv(resolvedEnv);
       await registerCustomProviders({
-        customEnv: { ...pickProviderEnv(process.env), ...env },
+        customEnv: { ...pickProviderEnv(authenticationEnvironment), ...env },
         registries,
         clientApp,
       });
       return;
     }
     case 'ai-gateway': {
-      const gatewayAuth = getAiGatewayAuthFromEnv({ env: process.env });
+      const gatewayAuth = getAiGatewayAuthFromEnv({
+        env: authenticationEnvironment,
+      });
       const gatewayApiKey =
         resolvedEnv.AI_GATEWAY_API_KEY ?? gatewayAuth.apiKey;
       const gatewayBaseUrl =
@@ -271,13 +371,13 @@ export async function registerPiProviders({
       });
       return;
     }
-    case 'legacy':
-      break; // handled below
     case 'auto':
     default: {
       // 'auto' (the default): prefer the AI Gateway; only when no gateway
       // credentials exist, fall back to other providers found in the env.
-      const gatewayAuth = getAiGatewayAuthFromEnv({ env: process.env });
+      const gatewayAuth = getAiGatewayAuthFromEnv({
+        env: authenticationEnvironment,
+      });
       const gatewayApiKey =
         resolvedEnv.AI_GATEWAY_API_KEY ?? gatewayAuth.apiKey;
       const gatewayBaseUrl =
@@ -297,25 +397,13 @@ export async function registerPiProviders({
       }
       const env = pickProviderEnv(resolvedEnv);
       await registerCustomProviders({
-        customEnv: { ...pickProviderEnv(process.env), ...env },
+        customEnv: { ...pickProviderEnv(authenticationEnvironment), ...env },
         registries,
         clientApp,
       });
       return;
     }
   }
-
-  // Legacy explicit gateway object options.
-  const apiKey = resolvedEnv.AI_GATEWAY_API_KEY;
-  const baseUrl = resolvedEnv.AI_GATEWAY_BASE_URL;
-  if (!apiKey || !baseUrl) return;
-
-  await register({
-    registries,
-    provider: 'vercel-ai-gateway',
-    apiKey,
-    config: createGatewayProviderConfig({ apiKey, baseUrl, clientApp }),
-  });
 }
 
 function pickOpenAIEnv(
@@ -363,46 +451,6 @@ function pickProviderEnv(
   return result;
 }
 
-function normalizePiAuthToLegacyAuth(
-  options: PiAuthOptions | undefined,
-): LegacyPiAuthOptions | undefined {
-  if (options == null || options === 'auto') {
-    return undefined;
-  }
-  if (typeof options === 'string') {
-    switch (options) {
-      case 'ai-gateway':
-        return { gateway: {} };
-      case 'custom':
-      case 'openai':
-      case 'anthropic':
-        return { customEnv: {} };
-      default:
-        return undefined;
-    }
-  }
-
-  console.warn(
-    '[pi] Passing an object to auth options is deprecated. Use a string mode ("auto" | "openai" | "anthropic" | "custom" | "ai-gateway") instead, and pass credentials via environment variables.',
-  );
-  return options;
-}
-
-function resolveCustomEnv({
-  customEnv,
-}: {
-  customEnv: Record<string, string>;
-}): Record<string, string> {
-  const apiKey = customEnv.AI_GATEWAY_API_KEY;
-  if (!apiKey) return {};
-
-  return {
-    AI_GATEWAY_API_KEY: apiKey,
-    AI_GATEWAY_BASE_URL:
-      customEnv.AI_GATEWAY_BASE_URL ?? DEFAULT_GATEWAY_BASE_URL,
-  };
-}
-
 async function registerCustomProviders({
   customEnv,
   registries,

package/src/pi-harness.ts

@@ -6,7 +6,7 @@ import {
 import { tool } from '@ai-sdk/provider-utils';
 import type { ExtensionFactory } from '@earendil-works/pi-coding-agent';
 import { z } from 'zod/v4';
-import type { PiAuthOptions } from './pi-auth';
+import type { PiAuthenticationMode } from './pi-auth';
 import { piResumeStateSchema } from './pi-resume-state';
 import { createPiSession, type PiThinkingLevel } from './pi-session';
 import { VERSION } from './version';
@@ -22,11 +22,13 @@ const PI_CLIENT_APP = `ai-sdk/harness-pi/${VERSION}`;
  */
 export type PiHarnessSettings = {
   /** Where Pi sources API keys / gateway credentials from. */
-  readonly auth?: PiAuthOptions;
+  readonly auth?: PiAuthenticationMode;
   /**
    * Pi model id (or name). Leaving this unset falls back to the AI Gateway
    * default when `AI_GATEWAY_API_KEY` / `VERCEL_OIDC_TOKEN` is set, and to
    * Pi's own resolution otherwise.
+   *
+   * @deprecated Use `model` on `HarnessAgent` instead.
    */
   readonly model?: string;
   /**
@@ -140,6 +142,7 @@ export function createPi(
     supportsBuiltinToolFiltering: true,
     lifecycleStateSchema: piResumeStateSchema,
     doStart: async startOpts => {
+      const model = startOpts.model ?? settings.model;
       const lifecycleState = startOpts.continueFrom ?? startOpts.resumeFrom;
       const resumeData = lifecycleState?.data as
         | { sessionFileName?: string }
@@ -149,10 +152,9 @@ export function createPi(
         sessionId: startOpts.sessionId,
         sandboxSession: startOpts.sandboxSession,
         sessionWorkDir: startOpts.sessionWorkDir,
-        skills: startOpts.skills ?? [],
         settings: {
           ...(settings.auth ? { auth: settings.auth } : {}),
-          ...(settings.model ? { model: settings.model } : {}),
+          ...(model == null ? {} : { model }),
           ...(settings.thinkingLevel
             ? { thinkingLevel: settings.thinkingLevel }
             : {}),

package/src/pi-session.ts

@@ -3,7 +3,6 @@ import {
   DefaultResourceLoader,
   defineTool,
   ModelRegistry,
-  ModelRuntime,
   SessionManager,
   SettingsManager,
   type AgentSession,
@@ -37,9 +36,10 @@ import {
 } from '@ai-sdk/harness/utils';
 import type { Experimental_SandboxSession as SandboxSession } from '@ai-sdk/provider-utils';
 import {
+  createPiModelRuntime,
   registerPiProviders,
   resolvePiEnv,
-  type PiAuthOptions,
+  type PiAuthenticationMode,
 } from './pi-auth';
 import { getPiTerminalError, parseNativeEvent } from './pi-events';
 import { createPiModelResolver } from './pi-model-resolver';
@@ -212,10 +212,11 @@ export type PiThinkingLevel =
   | 'low'
   | 'medium'
   | 'high'
-  | 'xhigh';
+  | 'xhigh'
+  | 'max';
 
 export interface PiSessionSettings {
-  readonly auth?: PiAuthOptions;
+  readonly auth?: PiAuthenticationMode;
   readonly model?: string;
   readonly thinkingLevel?: PiThinkingLevel;
   readonly mcpServers?: Record<string, unknown>;
@@ -226,7 +227,6 @@ export interface CreatePiSessionInput {
   readonly sessionId: string;
   readonly sandboxSession: HarnessV1NetworkSandboxSession | SandboxSession;
   readonly sessionWorkDir: string;
-  readonly skills: ReadonlyArray<HarnessV1Skill>;
   readonly settings: PiSessionSettings;
   readonly clientApp: string;
   readonly isResume: boolean;
@@ -331,24 +331,13 @@ export async function createPiSession(
     sessionId: input.sessionId,
   });
   const permissionMode = input.permissionMode ?? 'allow-all';
-  let sandboxSkillRootDir: string | undefined;
+  const sandboxSkillRootDir = path.posix.join(
+    sandboxHomeDir,
+    '.agents',
+    'skills',
+  );
   let harnessSkills: Skill[] = [];
 
-  // Materialise harness-provided skills into sandbox HOME, not the workspace.
-  if (input.skills.length > 0) {
-    sandboxSkillRootDir = path.posix.join(sandboxHomeDir, '.agents', 'skills');
-    harnessSkills = createHarnessPiSkills({
-      skills: input.skills,
-      sandboxSkillRootDir,
-    });
-    await writePiSkills({
-      sandbox: toolSafeSandboxSession,
-      sandboxHomeDir,
-      skills: input.skills,
-      ...(input.abortSignal ? { abortSignal: input.abortSignal } : {}),
-    });
-  }
-
   // On resume: pull the Pi session file out of the sandbox into the fresh
   // host mirror so SessionManager.open can read it.
   let resumeSessionFilePath: string | undefined;
@@ -384,20 +373,23 @@ export async function createPiSession(
   const paths = createPiPathMapper({
     hostWorkDir,
     sandboxWorkDir: sessionWorkDir,
-    readableRoots: sandboxSkillRootDir
-      ? [{ sandboxDir: sandboxSkillRootDir }]
-      : [],
+    readableRoots: [{ sandboxDir: sandboxSkillRootDir }],
   });
 
   // Pi auth + model registry are global to this Pi session. These live on the
   // real host filesystem, never in the sandbox/workspace.
   // When `agentDir` is provided, use it instead so the harness can reuse
   // existing CLI logins and model/settings config.
+  /*
+   * A record-shaped authentication override makes createPiModelRuntime ignore
+   * auth.json and models.json because both files can supply credentials from
+   * outside that record. General Pi settings still use agentDir below.
+   */
   const agentDir = input.agentDir ?? hostAgentDir;
-  const modelRuntime = await ModelRuntime.create({
+  const modelRuntime = await createPiModelRuntime({
+    auth: input.settings.auth,
     authPath: path.join(agentDir, 'auth.json'),
     modelsPath: path.join(agentDir, 'models.json'),
-    allowModelNetwork: false,
   });
   const modelRegistry = new ModelRegistry(modelRuntime);
   const settingsManager =
@@ -792,6 +784,7 @@ export async function createPiSession(
           // rebuilding the Pi session from it.
           const control = await runTurn({
             text: '',
+            skills: continueOpts.skills,
             tools: continueOpts.tools ?? [],
             instructions: continueOpts.instructions,
             emit: continueOpts.emit,
@@ -1068,6 +1061,7 @@ export async function createPiSession(
    */
   async function runTurn(turnOpts: {
     text: string;
+    skills: ReadonlyArray<HarnessV1Skill>;
     tools: ReadonlyArray<HarnessV1ToolSpec>;
     instructions?: string;
     emit: (part: HarnessV1StreamPart) => void;
@@ -1077,6 +1071,20 @@ export async function createPiSession(
       throw new Error('Pi session has been stopped.');
     }
 
+    const skillWriteResult = await writePiSkills({
+      sandbox: toolSafeSandboxSession,
+      sandboxHomeDir,
+      skills: turnOpts.skills,
+      abortSignal: turnOpts.abortSignal,
+    });
+    harnessSkills = createHarnessPiSkills({
+      skills: turnOpts.skills,
+      sandboxSkillRootDir,
+    });
+    if (piSession != null && skillWriteResult.changed) {
+      await reloadResourcesOnly();
+    }
+
     const userTools = turnOpts.tools;
     currentEmit = turnOpts.emit;
     const turnAbortController = new AbortController();
@@ -1329,6 +1337,7 @@ export async function createPiSession(
       }
       return runTurn({
         text: extractUserText(promptOpts.prompt),
+        skills: promptOpts.skills,
         tools: promptOpts.tools ?? [],
         instructions: promptOpts.instructions,
         emit: promptOpts.emit,
@@ -1385,6 +1394,7 @@ export async function createPiSession(
        */
       return runTurn({
         text: '',
+        skills: continueOpts.skills,
         tools: continueOpts.tools ?? [],
         instructions: continueOpts.instructions,
         emit: continueOpts.emit,