agent-relay-runner 0.91.2 → 0.91.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-runner",
-  "version": "0.91.2",
+  "version": "0.91.4",
   "description": "Unified provider lifecycle runner for Agent Relay",
   "type": "module",
   "bin": {
@@ -20,7 +20,7 @@
     "directory": "runner"
   },
   "dependencies": {
-    "agent-relay-sdk": "0.2.70"
+    "agent-relay-sdk": "0.2.71"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/plugins/claude/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "agent-relay-runner",
   "description": "Thin Agent Relay runner bridge for Claude Code",
-  "version": "0.91.2",
+  "version": "0.91.4",
   "agentRelayContracts": {
     "providerPluginProtocol": 1
   }

package/src/adapters/claude.ts

@@ -9,7 +9,7 @@ import { sanitizeFsName } from "agent-relay-sdk/fs-name";
 import { profileAllowsRelayFeature, type ManagedProcess, type ProviderAdapter, type ProviderConfig, type ProviderStatusUpdate, type RunnerSpawnConfig, type SemanticStatus, type SpawnArgs } from "../adapter";
 import { collectClaudeSessionEvents } from "./claude-transcript";
 import type { SessionEvent } from "../session-insights";
-import { prepareClaudeProfileHome, profileUsesHostProviderGlobals } from "../profile-home";
+import { prepareClaudeProfileHome, profileUsesClaudeHostProviderGlobals } from "../profile-home";
 import { assembleLaunch, materializeLaunchAssembly, sessionStatusLineSettingsArgs } from "../launch-assembly";
 import { claudeProviderMessageText } from "./claude-delivery";
 import { buildRateLimitProviderState, gatedClaudeRateLimitStatus, parseClaudeRateLimitPane } from "../rate-limit";
@@ -223,7 +223,7 @@ export class ClaudeAdapter implements ProviderAdapter {
     // Create + bootstrap + auth-link the isolated config home (no-op for host base) so the
     // assembler's materialize step has somewhere to write the provisioned skills/plugins.
     prepareClaudeProfileHome(config);
-    const defaultArgs = profileUsesHostProviderGlobals(config) ? providerConfig.defaultArgs : [];
+    const defaultArgs = profileUsesClaudeHostProviderGlobals(config) ? providerConfig.defaultArgs : [];
     // #557 — ONE assembler owns the provisioning/vanilla/instruction launch surface
     // (--setting-sources, --plugin-dir, --mcp-config, status-line, --append-system-prompt);
     // profile-projection describes the SAME assembled result, so report == launch. The
@@ -236,7 +236,7 @@ export class ClaudeAdapter implements ProviderAdapter {
     // Isolated profiles run their own CLAUDE_CONFIG_DIR and must never route through
     // claude-rig — claude-rig resolves host rig config (and a bare `claude-rig` with no
     // rig key just errors out). Only host-base profiles may use claude-rig.
-    const usesClaudeRig = isClaudeRig && profileUsesHostProviderGlobals(config);
+    const usesClaudeRig = isClaudeRig && profileUsesClaudeHostProviderGlobals(config);
     const bypassRigDefaults = config.headless && usesClaudeRig && config.approvalMode !== "open";
     const rigPrefix = usesClaudeRig && !bypassRigDefaults && config.rig ? ["launch", config.rig] : [];
     const command = !usesClaudeRig || bypassRigDefaults || (!config.rig && !findClaudeRigRC(config.cwd))

package/src/config.ts

@@ -99,6 +99,11 @@ export function registrationTimeoutMsFromEnv(): number {
   return Number.isFinite(parsed) && parsed > 0 ? parsed : 60_000;
 }
 
+export function nativeSelfResumeTimeoutMsFromEnv(): number {
+  const parsed = Number(process.env.AGENT_RELAY_NATIVE_SELF_RESUME_TIMEOUT_MS);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 120_000;
+}
+
 export function agentProfileNameFromEnv(): string | undefined {
   return process.env.AGENT_RELAY_AGENT_PROFILE;
 }

package/src/launch-assembly.ts

@@ -7,9 +7,16 @@ import {
   type ProviderConfig,
   type RunnerSpawnConfig,
 } from "./adapter";
-import { hostUserScopeMcpServers, profileUsesHostProviderGlobals, providerHomePathFor } from "./profile-home";
+import {
+  claudeProjectConfigProjectionOn,
+  hostUserScopeMcpServers,
+  profileUsesClaudeHostProviderGlobals,
+  providerHomePathFor,
+} from "./profile-home";
 import {
   materializeResolvedAssets,
+  resolveClaudeProjectSkills,
+  resolveProjectClaudeSettings,
   resolveClaudeProvisionedPlugins,
   resolveClaudeProvisionedSkills,
   resolveCodexProvisionedSkills,
@@ -115,6 +122,10 @@ export interface AssembledLaunch {
   statusLine: boolean;
   /** Relay-provisioned skills materialized for this launch. */
   skills: AssembledAsset[];
+  /** Project `.claude/skills` materialized for this Claude launch (#668). */
+  projectSkills: AssembledAsset[];
+  /** Project `.claude/settings.json` sanitized and injected for this Claude launch (#669). */
+  projectSettings: { applied: boolean; keys: string[]; ignoredKeys: string[]; file?: string };
   /** Relay-provisioned plugins (Claude --plugin-dir). Empty for Codex (no plugin surface). */
   plugins: AssembledAsset[];
   mcp: AssembledMcp;
@@ -161,10 +172,27 @@ function hasSettingsArg(args: string[]): boolean {
 // --settings is already present (caller wins). Relocated from claude.ts (#557).
 export function sessionStatusLineSettingsArgs(...argLists: string[][]): string[] {
   if (argLists.some(hasSettingsArg)) return [];
-  return ["--settings", JSON.stringify({
+  return ["--settings", JSON.stringify(relayStatusLineSettings())];
+}
+
+function relayStatusLineSettings(): Record<string, unknown> {
+  return {
     statusLine: { type: "command", command: "agent-relay context-probe --wrap", refreshInterval: 30 },
     showThinkingSummaries: true,
-  })];
+  };
+}
+
+function claudeSettingsArgs(
+  projectSettings: Record<string, unknown>,
+  includeStatusLine: boolean,
+  ...argLists: string[][]
+): string[] {
+  if (argLists.some(hasSettingsArg)) return [];
+  const settings = {
+    ...projectSettings,
+    ...(includeStatusLine ? relayStatusLineSettings() : {}),
+  };
+  return Object.keys(settings).length ? ["--settings", JSON.stringify(settings)] : [];
 }
 
 // ── Instruction disposition (the vanilla floor's effect on the host instruction cascade) ──
@@ -198,11 +226,16 @@ function assembleInstructions(config: RunnerSpawnConfig): AssembledInstructions
 function assembleClaude(config: RunnerSpawnConfig, providerConfig: ProviderConfig, hostDefaultArgs: string[]): AssembledLaunch {
   const configHome = providerHomePathFor("claude", config);
   const vanilla = profileIsVanillaBase(config);
+  const projectConfigProjection = claudeProjectConfigProjectionOn(config);
   const relayPlugin = profileAllowsRelayFeature(config, "plugins");
   const relaySkills = profileAllowsRelayFeature(config, "skills");
   const statusLine = profileAllowsRelayFeature(config, "statusLine");
 
   const skills = configHome ? resolveClaudeProvisionedSkills(configHome, config) : [];
+  const projectSkills = configHome
+    ? resolveClaudeProjectSkills(configHome, config, new Set(skills.map((s) => s.name)))
+    : [];
+  const projectSettings = resolveProjectClaudeSettings(config);
   const provisionedPlugins = configHome ? resolveClaudeProvisionedPlugins(configHome, config) : [];
 
   // Plugin dirs (--plugin-dir loads explicitly, independent of --setting-sources):
@@ -212,7 +245,7 @@ function assembleClaude(config: RunnerSpawnConfig, providerConfig: ProviderConfi
   //   host plugin dirs → ONLY host-base profiles; isolated/vanilla must not pull them back in.
   const relayPluginDirs = relayPlugin ? [CLAUDE_RELAY_PLUGIN_DIR] : [];
   const provisionedPluginDirs = provisionedPlugins.map((p) => p.dir);
-  const hostPluginDirs = profileUsesHostProviderGlobals(config) ? providerConfig.pluginDirs : [];
+  const hostPluginDirs = profileUsesClaudeHostProviderGlobals(config) ? providerConfig.pluginDirs : [];
   const pluginDirs = [...new Set([...relayPluginDirs, ...provisionedPluginDirs, ...hostPluginDirs])];
 
   const provisionedMcp = profileProvisioning(config).mcpServers;
@@ -265,7 +298,7 @@ function assembleClaude(config: RunnerSpawnConfig, providerConfig: ProviderConfi
   // still excluded) when the launch both uses the host config home AND its mcp mode is host.
   // An isolated/minimal base has its own config home and never had the real host's user MCP,
   // so it stays relay+provisioned only even if a profile sets mode:"host".
-  const usesHostMcp = profileUsesHostProviderGlobals(config)
+  const usesHostMcp = profileUsesClaudeHostProviderGlobals(config)
     && (!config.agentProfile || config.agentProfile.mcp.mode === "host");
   const hostMcp = usesHostMcp ? hostUserScopeMcpServers() : {};
   const hostMcpServers = Object.keys(hostMcp).filter(
@@ -277,7 +310,7 @@ function assembleClaude(config: RunnerSpawnConfig, providerConfig: ProviderConfi
   // Launch order matches the historical claude buildSpawnArgs block exactly so existing
   // arg assertions hold: vanilla scope → plugin dirs → MCP → status-line → append.
   const args = [
-    ...(vanilla ? ["--setting-sources", "user"] : []),
+    ...(vanilla || projectConfigProjection ? ["--setting-sources", "user"] : []),
     ...pluginDirs.flatMap((dir) => ["--plugin-dir", dir]),
     ...claudeMcpLaunchArgs({
       relayUrl: config.relayUrl,
@@ -287,7 +320,7 @@ function assembleClaude(config: RunnerSpawnConfig, providerConfig: ProviderConfi
       hostServers: hostMcp,
       strict: strictMcp,
     }),
-    ...(statusLine ? sessionStatusLineSettingsArgs(hostDefaultArgs, config.providerArgs) : []),
+    ...claudeSettingsArgs(projectSettings.settings, statusLine, hostDefaultArgs, config.providerArgs),
     ...(config.systemPromptAppend ? ["--append-system-prompt", config.systemPromptAppend] : []),
   ];
 
@@ -302,6 +335,13 @@ function assembleClaude(config: RunnerSpawnConfig, providerConfig: ProviderConfi
     relayPlugin,
     statusLine,
     skills: skills.map((s) => ({ name: s.name, dir: s.dir })),
+    projectSkills: projectSkills.map((s) => ({ name: s.name, dir: s.dir })),
+    projectSettings: {
+      applied: projectSettings.applied,
+      keys: projectSettings.keys,
+      ignoredKeys: projectSettings.ignoredKeys,
+      ...(projectSettings.file ? { file: projectSettings.file } : {}),
+    },
     plugins: provisionedPlugins.map((p) => ({ name: p.name, dir: p.dir })),
     mcp: {
       relayEndpoint, strict: strictMcp, servers: mcpServers, projectServers, hostServers: hostMcpServers,
@@ -371,6 +411,8 @@ function assembleCodex(config: RunnerSpawnConfig, _providerConfig: ProviderConfi
     relayPlugin: false,
     statusLine: false,
     skills: provisionedSkills.map((s) => ({ name: s.name, dir: s.dir })),
+    projectSkills: [],
+    projectSettings: { applied: false, keys: [], ignoredKeys: [] },
     plugins: [],
     mcp: {
       relayEndpoint, strict: false, servers: mcpServers, projectServers, hostServers: [],
@@ -389,7 +431,7 @@ function assembleCodex(config: RunnerSpawnConfig, _providerConfig: ProviderConfi
  */
 export function assembleLaunch(provider: SpawnProvider, config: RunnerSpawnConfig, providerConfig: ProviderConfig): AssembledLaunch {
   if (provider === "codex") return assembleCodex(config, providerConfig);
-  const hostDefaultArgs = profileUsesHostProviderGlobals(config) ? providerConfig.defaultArgs : [];
+  const hostDefaultArgs = profileUsesClaudeHostProviderGlobals(config) ? providerConfig.defaultArgs : [];
   return assembleClaude(config, providerConfig, hostDefaultArgs);
 }
 
@@ -403,7 +445,9 @@ export function materializeLaunchAssembly(provider: SpawnProvider, config: Runne
   const configHome = providerHomePathFor(provider, config);
   if (!configHome) return;
   if (provider === "claude") {
-    materializeResolvedAssets(resolveClaudeProvisionedSkills(configHome, config));
+    const skills = resolveClaudeProvisionedSkills(configHome, config);
+    materializeResolvedAssets(skills);
+    materializeResolvedAssets(resolveClaudeProjectSkills(configHome, config, new Set(skills.map((s) => s.name))));
     materializeResolvedAssets(resolveClaudeProvisionedPlugins(configHome, config));
     return;
   }

package/src/native-self-resume.ts

@@ -0,0 +1,202 @@
+import { errMessage } from "agent-relay-sdk";
+import type { ProviderStatusEvent, SemanticStatus } from "./adapter";
+import { nativeSelfResumeTimeoutMsFromEnv } from "./config";
+
+interface RunnerTimelineEvent {
+  status: string;
+  id?: string;
+  timestamp: number;
+  title?: string;
+  body?: string;
+  icon?: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface NativeSelfResumeHandoff {
+  commandId: string;
+  generation?: number;
+  compactedAt?: number;
+  timer: ReturnType<typeof setTimeout>;
+  resolve: (result: Record<string, unknown>) => void;
+  reject: (error: Error) => void;
+  promise: Promise<Record<string, unknown>>;
+}
+
+export function isNativeSelfResumeCompact(type: string, params: Record<string, unknown>): boolean {
+  if (type !== "agent.compact") return false;
+  const selfResume = params.selfResume;
+  return Boolean(selfResume && typeof selfResume === "object" && !Array.isArray(selfResume) && (selfResume as Record<string, unknown>).mode === "native");
+}
+
+export class NativeSelfResumeTracker {
+  private current?: NativeSelfResumeHandoff;
+
+  get active(): NativeSelfResumeHandoff | undefined {
+    return this.current;
+  }
+
+  begin(commandId: string, params: Record<string, unknown>): NativeSelfResumeHandoff {
+    this.finish(this.current);
+    let resolve!: (result: Record<string, unknown>) => void;
+    let reject!: (error: Error) => void;
+    const promise = new Promise<Record<string, unknown>>((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    const selfResume = params.selfResume && typeof params.selfResume === "object" && !Array.isArray(params.selfResume)
+      ? params.selfResume as Record<string, unknown>
+      : undefined;
+    const generation = typeof selfResume?.generation === "number" ? selfResume.generation : undefined;
+    const timeoutMs = nativeSelfResumeTimeoutMsFromEnv();
+    const handoff: NativeSelfResumeHandoff = {
+      commandId,
+      generation,
+      promise,
+      resolve,
+      reject,
+      timer: setTimeout(() => {
+        if (this.current !== handoff) return;
+        this.current = undefined;
+        reject(new Error(`native self-resume timed out after ${Math.round(timeoutMs / 1000)}s`));
+      }, timeoutMs),
+    };
+    this.current = handoff;
+    return handoff;
+  }
+
+  finish(handoff?: NativeSelfResumeHandoff): void {
+    if (!handoff) return;
+    clearTimeout(handoff.timer);
+    if (this.current === handoff) this.current = undefined;
+  }
+
+  resolve(handoff: NativeSelfResumeHandoff, result: Record<string, unknown>): void {
+    this.finish(handoff);
+    handoff.resolve(result);
+  }
+
+  reject(handoff: NativeSelfResumeHandoff, error: Error): void {
+    this.finish(handoff);
+    handoff.reject(error);
+  }
+
+  noteCompacted(timestamp: number = Date.now()): void {
+    if (!this.current) return;
+    this.current.compactedAt = timestamp;
+  }
+}
+
+interface NativeSelfResumeRecoveryOptions {
+  handoff: NativeSelfResumeHandoff;
+  tracker: NativeSelfResumeTracker;
+  providerSessionId: string;
+  status: SemanticStatus;
+  diagnostics: Record<string, unknown>;
+  now: number;
+  publishTimeline(event: RunnerTimelineEvent): void;
+  setTerminalProviderExit(marker: Record<string, unknown>): void;
+  setProviderStatus(update: ProviderStatusEvent): void;
+  restartProvider(resumeId?: string): Promise<void>;
+  publishStatus(): void;
+  scheduleDrain(): void;
+}
+
+export async function recoverNativeSelfResumeExit(opts: NativeSelfResumeRecoveryOptions): Promise<void> {
+  const resumeId = typeof opts.diagnostics.claudeResumeId === "string" && opts.diagnostics.claudeResumeId.length > 0
+    ? opts.diagnostics.claudeResumeId
+    : undefined;
+  if (opts.handoff.compactedAt && resumeId) {
+    await recoverWithClaudeResume(opts, resumeId);
+    return;
+  }
+  await recoverWithFreshLaunch(opts, resumeId);
+}
+
+async function recoverWithClaudeResume(opts: NativeSelfResumeRecoveryOptions, resumeId: string): Promise<void> {
+  opts.publishTimeline({
+    status: "provider.restart_decision",
+    id: `provider-self-resume-relaunch-${opts.providerSessionId}-${opts.now}`,
+    timestamp: Date.now(),
+    title: "Self-resume relaunching",
+    body: `Claude exited during native self-resume; runner is relaunching with claude --resume ${resumeId}.`,
+    icon: "ti-refresh",
+    metadata: selfResumeMetadata(opts.handoff, opts.diagnostics, {
+      decision: "resume-native-self-resume",
+      reason: "self-resume-exit-after-compact",
+      claudeResumeId: resumeId,
+      compactedAt: opts.handoff.compactedAt,
+    }),
+  });
+  try {
+    await opts.restartProvider(resumeId);
+    opts.publishStatus();
+    opts.scheduleDrain();
+    opts.tracker.resolve(opts.handoff, { recovered: true, via: "claude-resume", claudeResumeId: resumeId });
+  } catch (error) {
+    const message = errMessage(error);
+    opts.setTerminalProviderExit(selfResumeMetadata(opts.handoff, opts.diagnostics, {
+      reason: "self-resume-relaunch-failed",
+      claudeResumeId: resumeId,
+      compactedAt: opts.handoff.compactedAt,
+      lastError: message,
+    }));
+    opts.setProviderStatus({
+      status: "offline",
+      reason: "provider-turn",
+      id: `provider-self-resume-relaunch-failed-${opts.providerSessionId}`,
+      clear: ["provider-turn", "subagent", "background-script"],
+    });
+    opts.tracker.reject(opts.handoff, new Error(`self-resume relaunch failed: ${message}`));
+  }
+}
+
+async function recoverWithFreshLaunch(opts: NativeSelfResumeRecoveryOptions, resumeId?: string): Promise<void> {
+  opts.publishTimeline({
+    status: "provider.restart_decision",
+    id: `provider-self-resume-fresh-launch-${opts.providerSessionId}-${opts.now}`,
+    timestamp: Date.now(),
+    title: "Self-resume fresh-launching",
+    body: "Claude exited during native self-resume before a compacted marker; runner is fresh-launching so Relay can inject the persisted continuation.",
+    icon: "ti-refresh",
+    metadata: selfResumeMetadata(opts.handoff, opts.diagnostics, {
+      decision: "fresh-launch-native-self-resume",
+      reason: "self-resume-exit-before-compact",
+      ...(resumeId ? { claudeResumeId: resumeId } : {}),
+    }),
+  });
+  try {
+    await opts.restartProvider();
+    opts.publishStatus();
+    opts.scheduleDrain();
+    opts.tracker.resolve(opts.handoff, {
+      recovered: true,
+      via: "fresh-launch",
+      ...(resumeId ? { claudeResumeId: resumeId } : {}),
+    });
+  } catch (error) {
+    const message = errMessage(error);
+    opts.setTerminalProviderExit(selfResumeMetadata(opts.handoff, opts.diagnostics, {
+      reason: "self-resume-fresh-launch-failed",
+      ...(resumeId ? { claudeResumeId: resumeId } : {}),
+      lastError: message,
+    }));
+    opts.setProviderStatus({
+      status: "offline",
+      reason: "provider-turn",
+      id: `provider-self-resume-fresh-launch-failed-${opts.providerSessionId}`,
+      clear: ["provider-turn", "subagent", "background-script"],
+    });
+    opts.tracker.reject(opts.handoff, new Error(`self-resume fresh launch failed: ${message}`));
+  }
+}
+
+function selfResumeMetadata(handoff: NativeSelfResumeHandoff, diagnostics: Record<string, unknown>, extra: Record<string, unknown>): Record<string, unknown> {
+  return {
+    eventType: "provider.restart_decision",
+    selfResume: true,
+    selfResumeCommandId: handoff.commandId,
+    selfResumeGeneration: handoff.generation ?? null,
+    ...extra,
+    ...diagnostics,
+  };
+}

package/src/profile-home.ts

@@ -16,8 +16,18 @@ export function profileUsesHostProviderGlobals(config: { agentProfile?: RunnerSp
   return !config.agentProfile || config.agentProfile.base === "host";
 }
 
-function profileRequiresIsolatedHome(config: RunnerSpawnConfig): boolean {
-  return Boolean(config.agentProfile && config.agentProfile.base !== "host");
+export function claudeProjectConfigProjectionOn(config: { agentProfile?: RunnerSpawnConfig["agentProfile"] }): boolean {
+  return Boolean(config.agentProfile?.projectSkills || config.agentProfile?.projectSettings);
+}
+
+export function profileUsesClaudeHostProviderGlobals(config: { agentProfile?: RunnerSpawnConfig["agentProfile"] }): boolean {
+  return profileUsesHostProviderGlobals(config) && !claudeProjectConfigProjectionOn(config);
+}
+
+function profileRequiresIsolatedHome(provider: "claude" | "codex", config: RunnerSpawnConfig): boolean {
+  if (!config.agentProfile) return false;
+  if (config.agentProfile.base !== "host") return true;
+  return provider === "claude" && claudeProjectConfigProjectionOn(config);
 }
 
 // #557 — PURE: the isolated provider config home path a launch WILL use, or undefined
@@ -25,7 +35,7 @@ function profileRequiresIsolatedHome(config: RunnerSpawnConfig): boolean {
 // computes the home this way to report it + build CLAUDE_CONFIG_DIR/skill/plugin paths
 // without side effects; prepare*ProfileHome creates it at the same path at spawn time.
 export function providerHomePathFor(provider: "claude" | "codex", config: RunnerSpawnConfig): string | undefined {
-  if (!profileRequiresIsolatedHome(config)) return undefined;
+  if (!profileRequiresIsolatedHome(provider, config)) return undefined;
   return providerHomePath(provider, config);
 }
 
@@ -56,7 +66,7 @@ const CLAUDE_AUTH_ITEMS = [".credentials.json", "statsig"];
 // instance-keyed home, run the provider-specific first-run bootstrap. The
 // bootstrap step is the only genuinely provider-specific part.
 function prepareProviderHome(provider: "claude" | "codex", config: RunnerSpawnConfig): ProviderHome | undefined {
-  if (!profileRequiresIsolatedHome(config)) return undefined;
+  if (!profileRequiresIsolatedHome(provider, config)) return undefined;
   const target = providerHomePath(provider, config);
   mkdirSync(target, { recursive: true });
   const authLinked = provider === "codex"

package/src/profile-projection.ts

@@ -34,6 +34,8 @@ export function agentProfileProjectionReport(input: AgentProfileProjectionInput)
   add(provisioningPluginsEntry(assembled));
   add(provisioningMcpEntry(assembled));
   add(projectMcpEntry(assembled));
+  add(projectSkillsEntry(assembled));
+  add(projectSettingsEntry(assembled));
   add(sharedMcpEntry(assembled));
   if (profile) add(filesystemEntry(profile));
   add(configHomeEntry(assembled));
@@ -159,14 +161,30 @@ function projectMcpEntry(a: AssembledLaunch): AgentProfileProjectionEntry {
     : `Project .mcp.json servers emitted as -c mcp_servers.* overrides (${names.join(", ")}).`);
 }
 
-// #672 — shared host-listener MCP provenance. `not-applicable` when the profile/spawn didn't
-// opt in (the default); `applied` reports the per-agent `callmux bridge` routing the agent's
-// non-identity MCP (tokenlean, github) through the shared listener it points at. The server SET
-// is owned by the listener config, so this surfaces the route + URL, not an enumerated list.
+function projectSkillsEntry(a: AssembledLaunch): AgentProfileProjectionEntry {
+  const optedIn = Boolean(a.profile?.projectSkills);
+  if (!optedIn) return notApplicable("projectSkills", "off", "Project .claude/skills projection is off (opt in via the projectSkills profile/spawn option).");
+  if (a.provider !== "claude") return notApplicable("projectSkills", "unsupported", "Project .claude/skills projection applies to Claude launches only.");
+  if (!a.projectSkills.length) return applied("projectSkills", "none", "Project .claude/skills projection is on, but the spawn cwd declared no valid skill dirs.");
+  const names = a.projectSkills.map((s) => s.name).join(", ");
+  return applied("projectSkills", `${a.projectSkills.length}`, `Project .claude skills materialized into Relay's managed Claude config home (${names}); host/global skills are excluded.`);
+}
+
+function projectSettingsEntry(a: AssembledLaunch): AgentProfileProjectionEntry {
+  const optedIn = Boolean(a.profile?.projectSettings);
+  if (!optedIn) return notApplicable("projectSettings", "off", "Project .claude/settings.json projection is off (opt in via the projectSettings profile/spawn option).");
+  if (a.provider !== "claude") return notApplicable("projectSettings", "unsupported", "Project .claude/settings.json projection applies to Claude launches only.");
+  const ignored = a.projectSettings.ignoredKeys.length ? `; ignored security keys: ${a.projectSettings.ignoredKeys.join(", ")}` : "";
+  return applied("projectSettings", a.projectSettings.keys.length ? `${a.projectSettings.keys.length} keys` : "none", `Project .claude/settings.json was sanitized and injected through --settings; Relay approvalMode/permission gates remain authoritative${ignored}.`);
+}
+
+// #672/#689 — shared host-listener MCP provenance. `applied` reports the per-agent `callmux
+// bridge` route. `not-applicable` means the resolved profile kept shared MCP off (for example a
+// zero-host profile, explicit false, or global kill-switch normalization before launch).
 function sharedMcpEntry(a: AssembledLaunch): AgentProfileProjectionEntry {
   const optedIn = Boolean(a.profile?.sharedMcp);
   const listener = a.mcp.sharedListener;
-  if (!optedIn || !listener) return notApplicable("sharedMcp", "off", "Shared host-listener MCP is off (opt in via the sharedMcp profile/spawn option); non-identity MCP is injected per-agent.");
+  if (!optedIn || !listener) return notApplicable("sharedMcp", "off", "Shared host-listener MCP is off for this resolved profile; non-identity MCP is injected per-agent.");
   return applied("sharedMcp", "on", a.provider === "claude"
     ? `Non-identity MCP (e.g. tokenlean, github) routed through the shared callmux listener (${listener.url}) via a per-agent 'callmux bridge --cwd "$WORKTREE"', injected into --mcp-config (survives --strict-mcp-config); session survives a listener restart, session-cwd isolated. Relay endpoint stays per-agent (#215).`
     : `Non-identity MCP (e.g. tokenlean, github) routed through the shared callmux listener (${listener.url}) via a per-agent 'callmux bridge --cwd "$WORKTREE"' emitted as -c mcp_servers.* overrides; session survives a listener restart, session-cwd isolated. Relay endpoint stays per-agent (#215).`);

package/src/provisioning.ts

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readFileSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 import { sanitizeFsName } from "agent-relay-sdk/fs-name";
 import type { ProvisioningAssetFile, ProvisioningMcpServer, ResolvedProvisioning } from "agent-relay-sdk";
@@ -74,6 +74,88 @@ export function resolveProjectMcpServers(
   return out;
 }
 
+export function resolveClaudeProjectSkills(
+  claudeHome: string,
+  config: Pick<RunnerSpawnConfig, "agentProfile" | "cwd">,
+  reservedNames: ReadonlySet<string> = new Set(),
+): ResolvedAsset[] {
+  if (!config.agentProfile?.projectSkills) return [];
+  const skillsRoot = join(config.cwd, ".claude", "skills");
+  if (!existsSync(skillsRoot)) return [];
+  const targetRoot = join(claudeHome, "skills");
+  const resolved: ResolvedAsset[] = [];
+  for (const entry of readdirSync(skillsRoot, { withFileTypes: true })) {
+    if (!entry.isDirectory() || reservedNames.has(entry.name)) continue;
+    const source = join(skillsRoot, entry.name);
+    if (!existsSync(join(source, "SKILL.md"))) continue;
+    resolved.push({
+      name: entry.name,
+      dir: join(targetRoot, assetDirName(entry.name)),
+      source: { kind: "link", source },
+    });
+  }
+  return resolved.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+const UNSAFE_PROJECT_CLAUDE_SETTINGS = new Set([
+  "apiKeyHelper",
+  "allowDangerouslySkipPermissions",
+  "allowedTools",
+  "disabledMcpjsonServers",
+  "disallowedTools",
+  "enableAllProjectMcpServers",
+  "enabledMcpjsonServers",
+  "env",
+  "hooks",
+  "mcpServers",
+  "permissionMode",
+  "permissions",
+  "statusLine",
+  "tools",
+]);
+
+export interface ResolvedProjectClaudeSettings {
+  applied: boolean;
+  settings: Record<string, unknown>;
+  keys: string[];
+  ignoredKeys: string[];
+  file?: string;
+}
+
+export function resolveProjectClaudeSettings(
+  config: Pick<RunnerSpawnConfig, "agentProfile" | "cwd">,
+): ResolvedProjectClaudeSettings {
+  if (!config.agentProfile?.projectSettings) return { applied: false, settings: {}, keys: [], ignoredKeys: [] };
+  const file = join(config.cwd, ".claude", "settings.json");
+  if (!existsSync(file)) return { applied: true, settings: {}, keys: [], ignoredKeys: [], file };
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(readFileSync(file, "utf8"));
+  } catch (err) {
+    console.warn(`project .claude/settings.json projection: failed to parse ${file}: ${(err as Error).message}`);
+    return { applied: true, settings: {}, keys: [], ignoredKeys: [], file };
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return { applied: true, settings: {}, keys: [], ignoredKeys: [], file };
+  }
+  const settings: Record<string, unknown> = {};
+  const ignoredKeys: string[] = [];
+  for (const [key, value] of Object.entries(parsed as Record<string, unknown>)) {
+    if (UNSAFE_PROJECT_CLAUDE_SETTINGS.has(key)) {
+      ignoredKeys.push(key);
+      continue;
+    }
+    settings[key] = value;
+  }
+  return {
+    applied: true,
+    settings,
+    keys: Object.keys(settings).sort(),
+    ignoredKeys: ignoredKeys.sort(),
+    file,
+  };
+}
+
 // A resolved provisioning asset: WHERE it lands (`dir`) and HOW it materializes
 // (`source`). `files` writes the inline set into `dir`; `link` symlinks a pre-existing
 // source dir at `dir`; `inPlace` uses the source dir as-is (no write, dir IS the source).

package/src/relay-injection-events.ts

@@ -39,7 +39,9 @@ function launchInjectionEvents(input: RunnerLaunchInjectionInput): KeyedRelayInj
   if (!supportsLaunchAssembly(input.provider)) return events;
   const assembled = assembleLaunch(input.provider, input.config, input.providerConfig);
   const toolCount = assembled.skills.length + assembled.plugins.length + assembled.mcp.servers.length
+    + assembled.projectSkills.length
     + assembled.mcp.projectServers.length
+    + (assembled.projectSettings.applied ? 1 : 0)
     + (assembled.relaySkills ? 1 : 0)
     + (assembled.relayPlugin ? 1 : 0)
     + (assembled.mcp.relayEndpoint ? 1 : 0)
@@ -51,6 +53,8 @@ function launchInjectionEvents(input: RunnerLaunchInjectionInput): KeyedRelayInj
     assembled.statusLine ? "status line" : "",
     assembled.mcp.relayEndpoint ? "relay MCP" : "",
     assembled.skills.length ? `${assembled.skills.length} skill${assembled.skills.length === 1 ? "" : "s"}` : "",
+    assembled.projectSkills.length ? `${assembled.projectSkills.length} project skill${assembled.projectSkills.length === 1 ? "" : "s"}` : "",
+    assembled.projectSettings.applied ? "project settings" : "",
     assembled.plugins.length ? `${assembled.plugins.length} plugin${assembled.plugins.length === 1 ? "" : "s"}` : "",
     assembled.mcp.servers.length ? `${assembled.mcp.servers.length} MCP server${assembled.mcp.servers.length === 1 ? "" : "s"}` : "",
     assembled.mcp.projectServers.length ? `${assembled.mcp.projectServers.length} project MCP server${assembled.mcp.projectServers.length === 1 ? "" : "s"}` : "",
@@ -70,6 +74,8 @@ function launchInjectionEvents(input: RunnerLaunchInjectionInput): KeyedRelayInj
         relayPlugin: assembled.relayPlugin,
         statusLine: assembled.statusLine,
         skills: assembled.skills,
+        projectSkills: assembled.projectSkills,
+        projectSettings: assembled.projectSettings,
         plugins: assembled.plugins,
         mcp: assembled.mcp,
       },

package/src/runner-core.ts

@@ -16,7 +16,7 @@ import { startControlServer, type ControlServer } from "./control-server";
 import { ReplyObligationCache, obligationRequiresExplicitReply, responseCaptureReplyRoute } from "./reply-obligation-cache";
 import { Outbox, type OutboxRecord } from "./outbox";
 import { extractLastAssistantTurn, extractLastAssistantTurnAfterEntry, countTranscriptEntries, extractFinalAssistantMessage, extractFinalAssistantMessageAfterEntry, extractHookAssistantMessage, extractLatestTurnSteps, stepDedupKeys, transcriptLooksComplete } from "./adapters/claude-transcript";
-import { profileUsesHostProviderGlobals } from "./profile-home";
+import { profileUsesClaudeHostProviderGlobals, profileUsesHostProviderGlobals } from "./profile-home";
 import { RELAY_MCP_TOKEN_ENV, relayMcpEndpoint, resolveSharedMcpUrl } from "./relay-mcp";
 import { RelayMcpProxy } from "./relay-mcp-proxy";
 import { runtimeMetadata } from "./version";
@@ -30,6 +30,7 @@ import { runnerLaunchInjectionSessionEvents, type RunnerRelayInjectionEvent } fr
 import { providerTerminalSession, providerTerminalSocket } from "./process-meta";
 import { capsFromEnv, logLevelFromEnv, mcpProxyEnabledFromEnv, orchestratorBaseDirFromEnv, orchestratorUrlFromEnv, registrationTimeoutMsFromEnv, runnerInfoFileFromEnv, runnerLogFileFromEnv, runnerOutboxDirWithInfoFallback, sessionDebugEnabled, tagsFromEnv, workspaceModeFromEnv } from "./config";
 import { boundaryReasonForCommand, PRE_DESTROY_TIMEOUT_MS, reasonExitsRunner, type LifecycleAction, type SessionDestroyReason } from "./session-destroy";
+import { isNativeSelfResumeCompact, NativeSelfResumeTracker, recoverNativeSelfResumeExit } from "./native-self-resume";
 import {
   appliedAgentProfileMetadata,
   commandTimeoutMs,
@@ -38,8 +39,8 @@ import {
   isContextState,
   isHttpAuthError,
   isHttpStatusError,
-  latestClaudeResumeIdFromLogFile,
   lifecycleCapabilities,
+  providerExitDiagnostics,
   providerStateFromActiveWork,
   registerWithinDeadline,
   relayBusUrl,
@@ -198,6 +199,7 @@ export class AgentRunner {
   // terminal `agent.exited` event with a #636 diagnosis instead of the death going silent. Cleared
   // on any genuine restart back to busy/idle.
   private terminalProviderExit?: Record<string, unknown>;
+  private nativeSelfResume = new NativeSelfResumeTracker();
   private exitCommandInProgress = false;
   private restartInProgress = false;
   // Set for the whole unexpected-exit restart, including the pre-restart backoff
@@ -521,10 +523,10 @@ export class AgentRunner {
     return mode === "isolated";
   }
 
-  private async spawnProvider(): Promise<ManagedProcess> {
+  private async spawnProvider(opts: { resumeId?: string; suppressPrompt?: boolean } = {}): Promise<ManagedProcess> {
     this.providerSessionId = crypto.randomUUID();
     this.lastTranscriptPath = undefined;
-    const includeProviderGlobals = profileUsesHostProviderGlobals(this.options);
+    const includeProviderGlobals = this.options.provider === "claude" ? profileUsesClaudeHostProviderGlobals(this.options) : profileUsesHostProviderGlobals(this.options);
     const env = {
       ...process.env as Record<string, string>,
       ...(includeProviderGlobals ? this.options.providerConfig.env : {}),
@@ -571,10 +573,10 @@ export class AgentRunner {
       ...(this.options.rig ? { rig: this.options.rig } : {}),
       ...(this.options.profile ? { profile: this.options.profile } : {}),
       ...(this.options.agentProfile ? { agentProfile: this.options.agentProfile } : {}),
-      ...(this.options.prompt ? { prompt: this.options.prompt } : {}),
+      ...(this.options.prompt && !opts.resumeId && !opts.suppressPrompt ? { prompt: this.options.prompt } : {}),
       ...(this.options.systemPromptAppend ? { systemPromptAppend: this.options.systemPromptAppend } : {}),
       ...(this.options.tmuxSession ? { tmuxSession: this.options.tmuxSession } : {}),
-      providerArgs: this.options.providerArgs,
+      providerArgs: opts.resumeId ? [...this.options.providerArgs, "--resume", opts.resumeId] : this.options.providerArgs,
       providerConfig: this.options.providerConfig,
       env,
       controlPort: this.control!.port,
@@ -588,7 +590,7 @@ export class AgentRunner {
         deliver: (messages) => this.control!.deliverToMonitor(messages),
       },
     };
-    const launchSeededPrompt = this.options.adapter.seedsInitialPromptAtLaunch ? this.options.prompt?.trim() : ""; if (launchSeededPrompt) this.recordInjectedPrompt(launchSeededPrompt);
+    const launchSeededPrompt = this.options.adapter.seedsInitialPromptAtLaunch && !opts.resumeId && !opts.suppressPrompt ? this.options.prompt?.trim() : ""; if (launchSeededPrompt) this.recordInjectedPrompt(launchSeededPrompt);
     const managedProcess = await this.options.adapter.spawn(config);
     const injectionEvents = runnerLaunchInjectionSessionEvents({ carried: this.options.relayInjectionEvents, provider: this.options.provider, config, providerConfig: this.options.providerConfig, agentId: this.agentId, providerSessionId: this.providerSessionId });
     for (const event of injectionEvents) {
@@ -744,6 +746,9 @@ export class AgentRunner {
 
     const exitAfterCommand = type === "agent.shutdown" || type === "agent.kill";
     if (exitAfterCommand) this.exitCommandInProgress = true;
+    const nativeSelfResume = isNativeSelfResumeCompact(type, params)
+      ? this.nativeSelfResume.begin(commandId, params)
+      : undefined;
     this.claims.startClaim("command", commandId);
     try {
       await this.updateCommand(commandId, "accepted");
@@ -767,6 +772,10 @@ export class AgentRunner {
         providerResult = await this.options.adapter.compact(this.process, {
           instructions: typeof params.instructions === "string" ? params.instructions : undefined,
         });
+        if (nativeSelfResume) {
+          const handoff = await nativeSelfResume.promise;
+          providerResult = { ...(providerResult ?? {}), nativeSelfResume: handoff };
+        }
       } else if (type === "agent.clearContext") {
         if (!this.options.adapter.clearContext || !this.process) throw new Error("provider does not support clearContext");
         providerResult = await this.options.adapter.clearContext(this.process);
@@ -793,6 +802,7 @@ export class AgentRunner {
         ...(providerResult ? { providerResult } : {}),
       });
     } catch (error) {
+      if (nativeSelfResume) this.nativeSelfResume.finish(nativeSelfResume);
       await this.updateCommand(commandId, "failed", undefined, errMessage(error)).catch(() => {});
     } finally {
       this.claims.finishClaim("command", commandId);
@@ -808,6 +818,7 @@ export class AgentRunner {
           }).finally(() => process.exit(0)), 10);
         }
       } else if (!this.stopped) {
+        if (nativeSelfResume) this.nativeSelfResume.finish(nativeSelfResume);
         this.lifecycleAction = undefined;
         this.publishStatus();
       }
@@ -904,7 +915,7 @@ export class AgentRunner {
     return attachmentText ? `${body}\n\n${attachmentText}` : body;
   }
 
-  private async restartProvider(): Promise<void> {
+  private async restartProvider(opts: { resumeId?: string; suppressPrompt?: boolean } = {}): Promise<void> {
     this.restartInProgress = true;
     try {
       if (this.process) {
@@ -918,7 +929,7 @@ export class AgentRunner {
       this.claims.clearWorkKind("subagent");
       this.claims.clearWorkKind("background-script");
       if (this.stopped) return;
-      this.process = await this.spawnProvider();
+      this.process = await this.spawnProvider(opts);
       this.processStartedAt = Date.now();
     } finally {
       this.restartInProgress = false;
@@ -956,7 +967,7 @@ export class AgentRunner {
       const recent = this.unexpectedExitTimes.filter((time) => now - time <= UNEXPECTED_EXIT_WINDOW_MS);
       recent.push(now);
       this.unexpectedExitTimes.splice(0, this.unexpectedExitTimes.length, ...recent);
-      const diagnostics = this.providerExitDiagnostics(status, runtimeMs);
+      const diagnostics = providerExitDiagnostics({ status, runtimeMs, processMeta: this.process?.meta, hasProcess: Boolean(this.process?.process), exitCommandInProgress: this.exitCommandInProgress, stopped: this.stopped, restartInProgress: this.restartInProgress, restartPending: this.restartPending, headless: this.options.headless, provider: this.options.provider, logFile: runnerLogFileFromEnv() });
 
       this.publishRunnerTimelineEvent({
         status: "provider.exit_detected",
@@ -971,6 +982,12 @@ export class AgentRunner {
         },
       });
 
+      const nativeSelfResume = this.nativeSelfResume.active;
+      if (nativeSelfResume && this.options.provider === "claude") {
+        await recoverNativeSelfResumeExit({ handoff: nativeSelfResume, tracker: this.nativeSelfResume, providerSessionId: this.providerSessionId, status, diagnostics, now, publishTimeline: (event) => this.publishRunnerTimelineEvent(event), setTerminalProviderExit: (marker) => { this.terminalProviderExit = marker; }, setProviderStatus: (update) => this.setProviderStatus(update), restartProvider: (resumeId) => this.restartProvider(resumeId ? { resumeId } : { suppressPrompt: true }), publishStatus: () => this.publishStatus(), scheduleDrain: () => this.scheduleDrain() });
+        return;
+      }
+
       if (this.shouldStopUnexpectedProviderExit(diagnostics)) {
         const hasResumeId = typeof diagnostics.claudeResumeId === "string" && diagnostics.claudeResumeId.length > 0;
         logger.warn("lifecycle", `${this.options.provider} exited; leaving agent offline for manual recovery`);
@@ -1104,28 +1121,6 @@ export class AgentRunner {
     this.publishStatus();
   }
 
-  private providerExitDiagnostics(status: SemanticStatus, runtimeMs: number): Record<string, unknown> {
-    const tmuxSession = typeof this.process?.meta?.tmuxSession === "string" ? this.process.meta.tmuxSession : undefined;
-    const tmuxSocket = typeof this.process?.meta?.tmuxSocket === "string" ? this.process.meta.tmuxSocket : undefined;
-    const exitSource = tmuxSession ? "tmux-session-ended" : this.process?.process ? "process-exit" : "provider-status";
-    const logFile = runnerLogFileFromEnv();
-    const claudeResumeId = this.options.provider === "claude" && logFile ? latestClaudeResumeIdFromLogFile(logFile) : undefined;
-    return {
-      status,
-      runtimeMs: Number.isFinite(runtimeMs) ? runtimeMs : null,
-      exitSource,
-      exitCommandInProgress: this.exitCommandInProgress,
-      stopped: this.stopped,
-      restartInProgress: this.restartInProgress,
-      restartPending: this.restartPending,
-      headless: this.options.headless,
-      hasTerminalSession: Boolean(tmuxSession),
-      tmuxSession: tmuxSession ?? null,
-      tmuxSocket: tmuxSocket ?? null,
-      claudeResumeId: claudeResumeId ?? null,
-    };
-  }
-
   private async updateCommand(commandId: string, status: string, result?: Record<string, unknown>, error?: string): Promise<void> {
     await this.bus.updateCommand(commandId, { status, ...(result ? { result } : {}), ...(error ? { error } : {}) });
   }
@@ -1222,6 +1217,7 @@ export class AgentRunner {
     if (timelineStatus === "compacting") {
       this.compactionMidTurn = this.currentTurnId !== undefined;
     } else if (timelineStatus === "compacted") {
+      this.nativeSelfResume.noteCompacted(typeof update !== "string" && typeof update.timeline?.timestamp === "number" ? update.timeline.timestamp : Date.now());
       this.publishCompactionNotice();
       if (this.compactionMidTurn) {
         // Keep the turn (and its live reasoning tail) alive; the genuine Stop hook ends it.
@@ -1304,6 +1300,9 @@ export class AgentRunner {
       this.rateLimitHold = hold;
       if (fresh) this.publishRateLimitNotice(hold);
     }
+    if (status === "idle" && this.nativeSelfResume.active) {
+      this.nativeSelfResume.resolve(this.nativeSelfResume.active, { resumed: true, via: "provider-idle" });
+    }
     this.publishStatus();
   }
 

package/src/runner-helpers.ts

@@ -157,6 +157,39 @@ export function latestClaudeResumeIdFromLogFile(path: string): string | undefine
   }
 }
 
+export function providerExitDiagnostics(input: {
+  status: SemanticStatus;
+  runtimeMs: number;
+  processMeta?: Record<string, unknown>;
+  hasProcess: boolean;
+  exitCommandInProgress: boolean;
+  stopped: boolean;
+  restartInProgress: boolean;
+  restartPending: boolean;
+  headless: boolean;
+  provider: string;
+  logFile?: string;
+}): Record<string, unknown> {
+  const tmuxSession = typeof input.processMeta?.tmuxSession === "string" ? input.processMeta.tmuxSession : undefined;
+  const tmuxSocket = typeof input.processMeta?.tmuxSocket === "string" ? input.processMeta.tmuxSocket : undefined;
+  const exitSource = tmuxSession ? "tmux-session-ended" : input.hasProcess ? "process-exit" : "provider-status";
+  const claudeResumeId = input.provider === "claude" && input.logFile ? latestClaudeResumeIdFromLogFile(input.logFile) : undefined;
+  return {
+    status: input.status,
+    runtimeMs: Number.isFinite(input.runtimeMs) ? input.runtimeMs : null,
+    exitSource,
+    exitCommandInProgress: input.exitCommandInProgress,
+    stopped: input.stopped,
+    restartInProgress: input.restartInProgress,
+    restartPending: input.restartPending,
+    headless: input.headless,
+    hasTerminalSession: Boolean(tmuxSession),
+    tmuxSession: tmuxSession ?? null,
+    tmuxSocket: tmuxSocket ?? null,
+    claudeResumeId: claudeResumeId ?? null,
+  };
+}
+
 export function commandTimeoutMs(params: Record<string, unknown>, fallback = 10_000): number {
   const raw = params.timeoutMs;
   if (typeof raw !== "number" || !Number.isSafeInteger(raw) || raw <= 0) return fallback;