From c237685a0a0668eaea8c18ce6442f24a36e7a9c0 Mon Sep 17 00:00:00 2001 From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com> Date: Fri, 20 Nov 2026 15:26:32 -0800 Subject: [PATCH] fix(inference): keep personal skills available in routed profiles --- .../src/provider/Drivers/ClaudeDriver.ts | 24 +++++- .../src/provider/Drivers/ClaudeHome.test.ts | 80 +++++++++++++++++++ .../server/src/provider/Drivers/ClaudeHome.ts | 17 ++++ .../src/provider/Drivers/CodexDriver.test.ts | 29 +++++++ .../src/provider/Drivers/CodexDriver.ts | 25 +++++- .../src/provider/Drivers/inferenceSkills.ts | 72 +++++++++++++++++ .../ProviderInstanceRegistryHydration.test.ts | 33 +++++++- .../ProviderInstanceRegistryHydration.ts | 16 +++- apps/server/src/skills/SkillsLibrary.test.ts | 9 ++- apps/server/src/skills/SkillsLibrary.ts | 20 ++++- docs/user/composer.md | 5 ++ packages/contracts/src/settings.test.ts | 2 + packages/contracts/src/settings.ts | 7 ++ 13 files changed, 329 insertions(+), 10 deletions(-) create mode 100644 apps/server/src/provider/Drivers/inferenceSkills.ts diff --git a/apps/server/src/provider/Drivers/ClaudeDriver.ts b/apps/server/src/provider/Drivers/ClaudeDriver.ts index cbf4827ef8852..2b3d5c1edbe96 100644 --- a/apps/server/src/provider/Drivers/ClaudeDriver.ts +++ b/apps/server/src/provider/Drivers/ClaudeDriver.ts @@ -65,6 +65,7 @@ import { mergeClaudeProcessEnvironment, } from "./ClaudeHome.ts"; import * as HostProcess from "@t3tools/shared/HostProcess"; +import { mergeProviderInstanceEnvironment } from "@t3tools/provider-core/server/instanceEnvironment"; import { makeClaudeMaintenanceResolution } from "./ClaudeMaintenance.ts"; const decodeClaudeSettings = Schema.decodeSync(ClaudeSettings); @@ -132,7 +133,19 @@ export const ClaudeDriver: ProviderDriver< enabled, binaryPath: expandHomePath(config.binaryPath, yield* HostProcess.HomeDirectory), }, - environment: yield* mergeClaudeProcessEnvironment(config, environment, process.env), + environment: yield* mergeClaudeProcessEnvironment( + config, + environment, + yield* HostProcess.Environment, + ), + ...(config.setupMode === "inference" + ? { + nativeEnvironment: yield* mergeProviderInstanceEnvironment( + environment, + yield* HostProcess.Environment, + ), + } + : {}), stateDir, }); const { config: effectiveConfig, environment: processEnv, configDir } = runtime; @@ -519,7 +532,8 @@ export const ClaudeDriver: ProviderDriver< return { instanceId, driverKind: DRIVER_KIND, - ...(runtime.overlay?.active === false + ...(runtime.overlay?.active === false || + (config.setupMode === "inference" && !config.shareProfile) ? {} : { sharedSkillsDirectory: path.join(runtime.overlay?.sharedRoot ?? configDir, "skills") }), continuationIdentity: { @@ -535,7 +549,11 @@ export const ClaudeDriver: ProviderDriver< invalidateCaches: Cache.invalidateAll(capabilitiesProbeCache), workspaceRescans: Stream.fromQueue(workspaceRescans), snapshotForCwd: (cwd: string) => - snapshot.getSnapshot.pipe( + (runtime.nativeSkillsHome === undefined + ? Effect.void + : materializeClaudeHome(runtime).pipe(Effect.ignoreCause({ log: true })) + ).pipe( + Effect.andThen(snapshot.getSnapshot), Effect.flatMap((machineSnapshot) => withAccess( probeClaudeWorkspaceSnapshot(effectiveConfig, machineSnapshot, cwd, processEnv), diff --git a/apps/server/src/provider/Drivers/ClaudeHome.test.ts b/apps/server/src/provider/Drivers/ClaudeHome.test.ts index 83653018d68a7..2285b25666195 100644 --- a/apps/server/src/provider/Drivers/ClaudeHome.test.ts +++ b/apps/server/src/provider/Drivers/ClaudeHome.test.ts @@ -9,6 +9,7 @@ import * as Path from "effect/Path"; import * as Schema from "effect/Schema"; import { ClaudeSettings, ProviderInstanceId } from "@t3tools/contracts"; import { symlinksSupported } from "@t3tools/shared/testing/symlinks"; +import * as HostProcess from "@t3tools/shared/HostProcess"; import { makeClaudeCapabilitiesCacheKey, @@ -19,6 +20,7 @@ import { mergeClaudeProcessEnvironment, resolveClaudeHomePath, } from "./ClaudeHome.ts"; +import { discoverClaudeSkills } from "./ClaudeSkills.ts"; const decodeClaudeSettings = Schema.decodeSync(ClaudeSettings); @@ -156,6 +158,84 @@ it.layer(NodeServices.layer)("ClaudeHome", (it) => { ); } + it.effect.skipIf(!symlinksSupported)("retains personal skills in an inference home", () => + Effect.gen(function* () { + const fs = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const root = yield* fs.makeTempDirectoryScoped({ prefix: "t3-claude-inference-" }); + const personal = path.join(root, "personal"); + const routed = path.join(root, "routed"); + const skill = (home: string, name: string) => path.join(home, "skills", name, "SKILL.md"); + for (const [home, name, body] of [ + [personal, "review", "Personal review"], + [personal, "existing", "Personal copy"], + [routed, "existing", "Routed copy"], + ] as const) { + yield* fs.makeDirectory(path.dirname(skill(home, name)), { recursive: true }); + yield* fs.writeFileString(skill(home, name), body); + } + yield* fs.writeFileString(path.join(personal, "settings.json"), "{}"); + + const runtime = yield* resolveClaudeRuntime({ + instanceId: ProviderInstanceId.make("claudeAgent"), + stateDir: root, + config: decodeClaudeSettings({ setupMode: "inference", homePath: routed }), + environment: { CLAUDE_CONFIG_DIR: routed }, + nativeEnvironment: { CLAUDE_CONFIG_DIR: personal }, + }).pipe(Effect.provideService(HostProcess.Environment, {})); + yield* materializeClaudeHome(runtime); + expect(yield* fs.readFileString(skill(routed, "existing"))).toBe("Routed copy"); + expect(yield* fs.exists(path.join(routed, "settings.json"))).toBe(false); + expect( + (yield* discoverClaudeSkills(runtime.config, undefined, runtime.environment)).map( + ({ name }) => name, + ), + ).toEqual(["existing", "review"]); + expect(yield* fs.readFileString(skill(routed, "review"))).toBe("Personal review"); + yield* fs.symlink( + path.dirname(skill(personal, "existing")), + path.dirname(skill(routed, "manual")), + ); + const alternate = path.join(root, "alternate"); + yield* fs.makeDirectory(path.dirname(skill(alternate, "review")), { recursive: true }); + yield* fs.writeFileString(skill(alternate, "review"), "Alternate review"); + const switched = yield* resolveClaudeRuntime({ + instanceId: ProviderInstanceId.make("claudeAgent"), + stateDir: root, + config: decodeClaudeSettings({ + setupMode: "inference", + homePath: routed, + inferenceSkillsHomePath: alternate, + }), + environment: { CLAUDE_CONFIG_DIR: routed }, + }); + yield* materializeClaudeHome(switched); + expect(yield* fs.readFileString(skill(routed, "review"))).toBe("Alternate review"); + yield* fs.remove(path.dirname(skill(alternate, "review")), { recursive: true }); + yield* materializeClaudeHome(switched); + expect((yield* fs.readDirectory(path.join(routed, "skills"))).sort()).toEqual([ + "existing", + "manual", + ]); + expect(yield* fs.readFileString(skill(routed, "manual"))).toBe("Personal copy"); + yield* materializeClaudeHome(runtime); + const privateRuntime = yield* resolveClaudeRuntime({ + instanceId: ProviderInstanceId.make("claudeAgent"), + stateDir: root, + config: decodeClaudeSettings({ + setupMode: "inference", + homePath: routed, + shareProfile: false, + }), + environment: { CLAUDE_CONFIG_DIR: routed }, + nativeEnvironment: { CLAUDE_CONFIG_DIR: personal }, + }); + yield* materializeClaudeHome(privateRuntime); + expect(yield* fs.exists(skill(routed, "review"))).toBe(false); + expect(yield* fs.readFileString(skill(routed, "manual"))).toBe("Personal copy"); + }), + ); + it.effect("separates capability probes by cwd", () => Effect.gen(function* () { const config = { binaryPath: "claude", homePath: "" }; diff --git a/apps/server/src/provider/Drivers/ClaudeHome.ts b/apps/server/src/provider/Drivers/ClaudeHome.ts index 59e10bcb47cdb..2094cf4a01dcf 100644 --- a/apps/server/src/provider/Drivers/ClaudeHome.ts +++ b/apps/server/src/provider/Drivers/ClaudeHome.ts @@ -21,6 +21,7 @@ import { expandHomePath } from "@t3tools/provider-core/server/pathExpansion"; import * as HostProcess from "@t3tools/shared/HostProcess"; import { readClaudeSettingsEnv } from "./ClaudeSkills.ts"; +import { linkInferenceSkills } from "./inferenceSkills.ts"; const quotePath = Schema.encodeSync(Schema.fromJsonString(Schema.String)); @@ -154,12 +155,14 @@ export type ClaudeRuntime = { readonly config: ClaudeSettings; readonly configDir: string; readonly overlay: undefined; + readonly nativeSkillsHome?: string; } | { readonly mode: "cli"; readonly config: ClaudeSettings & { readonly homePath: ClaudeAccountDir }; readonly configDir: ClaudeAccountDir; readonly overlay: HomeOverlay; + readonly nativeSkillsHome?: never; } ); @@ -168,6 +171,7 @@ export const resolveClaudeRuntime = Effect.fn("resolveClaudeRuntime")(function* readonly config: ClaudeSettings; readonly environment: NodeJS.ProcessEnv; readonly stateDir: string; + readonly nativeEnvironment?: NodeJS.ProcessEnv; }): Effect.fn.Return { if (input.config.setupMode !== "cli") { return { @@ -176,6 +180,14 @@ export const resolveClaudeRuntime = Effect.fn("resolveClaudeRuntime")(function* configDir: yield* resolveClaudeHomePath(input.config, input.environment), environment: yield* makeClaudeEnvironment(input.config, input.environment), overlay: undefined, + ...(input.config.setupMode === "inference" && input.config.shareProfile + ? { + nativeSkillsHome: yield* resolveClaudeHomePath( + { homePath: input.config.inferenceSkillsHomePath ?? "" }, + input.nativeEnvironment ?? (yield* HostProcess.Environment), + ), + } + : {}), }; } const path = yield* Path.Path; @@ -199,6 +211,11 @@ export const resolveClaudeRuntime = Effect.fn("resolveClaudeRuntime")(function* export const materializeClaudeHome = Effect.fn("materializeClaudeHome")(function* ( runtime: ClaudeRuntime, ) { + if (runtime.mode === "existing" && runtime.config.setupMode === "inference") { + yield* linkInferenceSkills(runtime.nativeSkillsHome, runtime.configDir, "synced").pipe( + Effect.ignoreCause({ log: true }), + ); + } if (!runtime.overlay) return; const fileSystem = yield* FileSystem.FileSystem; yield* fileSystem.makeDirectory(runtime.configDir, { recursive: true, mode: 0o700 }); diff --git a/apps/server/src/provider/Drivers/CodexDriver.test.ts b/apps/server/src/provider/Drivers/CodexDriver.test.ts index a1c2f557b81a2..4a709c40a4245 100644 --- a/apps/server/src/provider/Drivers/CodexDriver.test.ts +++ b/apps/server/src/provider/Drivers/CodexDriver.test.ts @@ -720,6 +720,35 @@ it.layer(layerTest)("CodexDriver", (it) => { }).pipe(Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, noSpawn)), ); + it.effect.skipIf(windowsHost)( + "keeps personal skills in an inference home without sharing auth", + () => + Effect.gen(function* () { + const fs = yield* FileSystem.FileSystem; + const root = yield* fs.makeTempDirectoryScoped({ prefix: "t3-codex-inference-" }); + const native = NodePath.join(root, "native"); + const routed = NodePath.join(root, "routed"); + const skill = (home: string, name: string) => + NodePath.join(home, "skills", name, "SKILL.md"); + for (const name of ["review", ".system"]) { + yield* fs.makeDirectory(NodePath.dirname(skill(native, name)), { recursive: true }); + yield* fs.writeFileString(skill(native, name), name); + } + yield* fs.writeFileString(NodePath.join(native, "auth.json"), "{}"); + const instance = yield* CodexDriver.create({ + instanceId: ProviderInstanceId.make("codex-inference"), + displayName: "Codex Inference", + enabled: false, + environment: [{ name: "CODEX_HOME", value: native, sensitive: false }], + config: { ...CodexDriver.defaultConfig(), homePath: routed, setupMode: "inference" }, + }); + expect(instance.continuationIdentity.continuationKey).toBe(`codex:home:${routed}`); + expect(yield* fs.readFileString(skill(routed, "review"))).toBe("review"); + expect(yield* fs.exists(skill(routed, ".system"))).toBe(false); + expect(yield* fs.exists(NodePath.join(routed, "auth.json"))).toBe(false); + }).pipe(Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, noSpawn)), + ); + it.effect.each(["inference", "existing"] as const)( "publishes models with the right provenance in %s mode", (setupMode) => diff --git a/apps/server/src/provider/Drivers/CodexDriver.ts b/apps/server/src/provider/Drivers/CodexDriver.ts index 20c9b510953c0..ad8e2c0acc612 100644 --- a/apps/server/src/provider/Drivers/CodexDriver.ts +++ b/apps/server/src/provider/Drivers/CodexDriver.ts @@ -60,10 +60,12 @@ import { codexContinuationIdentity, codexHomeLaunchArgs, materializeCodexShadowHome, + resolveCodexHomeLayout, } from "./CodexHomeLayout.ts"; import { resolveCodexRuntime } from "./CodexRuntime.ts"; import { makeManagedCodexProvider } from "./CodexManagedProvider.ts"; import { codexUsageReader } from "./codexUsage.ts"; +import { linkInferenceSkills } from "./inferenceSkills.ts"; import * as CodexInstallation from "../CodexInstallation.ts"; import * as CodexManagedTokenBroker from "../CodexManagedTokenBroker.ts"; import * as ServerSecretStore from "../../auth/ServerSecretStore.ts"; @@ -225,6 +227,26 @@ export const CodexDriver: ProviderDriver< }); const { homeLayout, environment: processEnv } = runtime; const accountKey = homeLayout.effectiveHomePath ?? homeLayout.sharedHomePath; + const nativeHome = + config.setupMode === "inference" + ? (yield* resolveCodexHomeLayout( + { + ...config, + homePath: config.inferenceSkillsHomePath ?? "", + shadowHomePath: "", + }, + instanceEnvironment, + )).sharedHomePath + : undefined; + const syncInferenceSkills = + nativeHome === undefined + ? Effect.void + : linkInferenceSkills(nativeHome, accountKey, ".system").pipe( + Effect.provideService(FileSystem.FileSystem, fileSystem), + Effect.provideService(Path.Path, pathService), + Effect.ignoreCause({ log: true }), + ); + yield* syncInferenceSkills; const runtimePaths = { homePath: homeLayout.sharedHomePath, shadowHomePath: accountKey, @@ -506,7 +528,8 @@ export const CodexDriver: ProviderDriver< : Effect.all([ snapshot.getSnapshot, withAccess( - resolveRuntime.pipe( + syncInferenceSkills.pipe( + Effect.andThen(resolveRuntime), Effect.flatMap((runtime) => probeSkills({ binaryPath: runtime.config.binaryPath, diff --git a/apps/server/src/provider/Drivers/inferenceSkills.ts b/apps/server/src/provider/Drivers/inferenceSkills.ts new file mode 100644 index 0000000000000..facc11bbafee5 --- /dev/null +++ b/apps/server/src/provider/Drivers/inferenceSkills.ts @@ -0,0 +1,72 @@ +import * as Effect from "effect/Effect"; +import * as FileSystem from "effect/FileSystem"; +import * as Path from "effect/Path"; + +export const linkInferenceSkills = Effect.fn("linkInferenceSkills")(function* ( + nativeHome: string | undefined, + inferenceHome: string, + privateEntry: string, +) { + if (nativeHome === inferenceHome) return; + const fs = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const source = nativeHome === undefined ? undefined : path.join(nativeHome, "skills"); + const destination = path.join(inferenceHome, "skills"); + const anchor = path.join(inferenceHome, ".t3-native-skills"); + const linkTarget = (entry: string) => + fs.readLink(entry).pipe(Effect.orElseSucceed(() => undefined)); + if ((yield* linkTarget(destination)) !== undefined) return; + const readNames = (directory: string) => + fs + .readDirectory(directory) + .pipe(Effect.catchReason("PlatformError", "NotFound", () => Effect.succeed([]))); + const names = new Set( + source === undefined + ? [] + : yield* Effect.filter( + (yield* readNames(source)).filter( + (name) => !name.startsWith(".") && name !== privateEntry, + ), + (name) => fs.exists(path.join(source, name, "SKILL.md")), + ), + ); + const previous = yield* linkTarget(anchor); + if (!names.size && previous === undefined) return; + const existing = new Set(yield* readNames(destination)); + for (const name of existing) { + if (names.has(name)) continue; + const entry = path.join(destination, name); + if ((yield* linkTarget(entry)) === path.join(anchor, name)) { + yield* fs.remove(entry, { force: true }); + } + } + if (!names.size || source === undefined) { + if (previous !== undefined) yield* fs.remove(anchor, { force: true }); + return; + } + yield* fs.makeDirectory(destination, { recursive: true, mode: 0o700 }); + if (previous === undefined) { + yield* fs + .symlink(source, anchor) + .pipe(Effect.catchReason("PlatformError", "AlreadyExists", () => Effect.void)); + if ((yield* linkTarget(anchor)) !== source) return; + } else if (previous !== source) { + yield* Effect.scoped( + Effect.gen(function* () { + const stage = yield* fs.makeTempDirectoryScoped({ + directory: inferenceHome, + prefix: ".t3-skills-", + }); + const replacement = path.join(stage, "source"); + yield* fs.symlink(source, replacement); + yield* fs.rename(replacement, anchor); + }), + ); + } + for (const name of names) { + if (existing.has(name)) continue; + yield* fs + .symlink(path.join(anchor, name), path.join(destination, name)) + .pipe(Effect.catchReason("PlatformError", "AlreadyExists", () => Effect.void)); + } +}); diff --git a/apps/server/src/provider/ProviderInstanceRegistryHydration.test.ts b/apps/server/src/provider/ProviderInstanceRegistryHydration.test.ts index 751d131ba87ec..cc659dc0583b2 100644 --- a/apps/server/src/provider/ProviderInstanceRegistryHydration.test.ts +++ b/apps/server/src/provider/ProviderInstanceRegistryHydration.test.ts @@ -154,6 +154,7 @@ describe("deriveProviderInstanceConfigMap", () => { config: { setupMode: "inference", homePath: "/proxy/home", + inferenceSkillsHomePath: "/native/home", shadowHomePath: "", customModels: ["gpt-fixture"], }, @@ -168,6 +169,23 @@ describe("deriveProviderInstanceConfigMap", () => { value: "proxy-key", sensitive: true, }); + for (const [kind, setupMode, homePath, expected] of [ + ["codex", "managed", "", "~/.codex"], + ["claudeAgent", "cli", "/ignored-by-cli", ""], + ] as const) { + const key = ProviderInstanceId.make(kind); + const active = deriveProviderInstanceConfigMap( + settingsWith({ + providerInstances: { + [key]: { + driver: ProviderDriverKind.make(kind), + config: { ...route, setupMode, homePath }, + }, + }, + }), + ); + expect(active[key]?.config).toMatchObject({ inferenceSkillsHomePath: expected }); + } expect(settings).toEqual(before); const disabled = deriveProviderInstanceConfigMap({ ...settings, @@ -210,7 +228,12 @@ describe("deriveProviderInstanceConfigMap", () => { inferenceHomePath: "/proxy/home", }, environment: [ - { name: "OPENCODE_CONFIG_CONTENT", value: '{"theme":"mine"}', sensitive: false }, + { + name: "OPENCODE_CONFIG_CONTENT", + value: '{"theme":"mine","skills":{"paths":["/native/skills"]}}', + sensitive: false, + }, + { name: "OPENCODE_CONFIG_DIR", value: "/native/opencode", sensitive: false }, ], }, [other]: { driver }, @@ -229,9 +252,15 @@ describe("deriveProviderInstanceConfigMap", () => { sensitive: true, }); const contents = environment.filter((entry) => entry.name === "OPENCODE_CONFIG_CONTENT"); + expect(environment).toContainEqual({ + name: "OPENCODE_CONFIG_DIR", + value: "/native/opencode", + sensitive: false, + }); expect(contents).toHaveLength(1); expect(JSON.parse(String(contents[0]?.value))).toMatchObject({ theme: "mine", + skills: { paths: ["/native/skills"] }, provider: { t3proxy: { models: { "grok-fixture": { name: "grok-fixture" } } } }, }); expect(JSON.parse(String(contents[0]?.value)).provider).not.toHaveProperty("host"); @@ -279,7 +308,7 @@ describe("deriveProviderInstanceConfigMap", () => { driver: ProviderDriverKind.make("pi"), displayName: "My Pi", config: { - launchArgs: "--provider native --model native-model", + launchArgs: "--provider native --model native-model --skill /native/extra-skill", customModels: ["native/native-model"], inferenceEnabled: true, inferenceHostId: "host", diff --git a/apps/server/src/provider/ProviderInstanceRegistryHydration.ts b/apps/server/src/provider/ProviderInstanceRegistryHydration.ts index 0b0380a2f1935..7542c21cbaba5 100644 --- a/apps/server/src/provider/ProviderInstanceRegistryHydration.ts +++ b/apps/server/src/provider/ProviderInstanceRegistryHydration.ts @@ -58,6 +58,14 @@ type ProviderInstanceRegistryHydrationEnv = // Adapter ids read which subagent threads predate short ids. | SqlClient.SqlClient; +function inferenceSkillsHome(driver: "claudeAgent" | "codex", config: object) { + const mode = "setupMode" in config ? config.setupMode : undefined; + if (driver === "claudeAgent" && mode === "cli") return ""; + const native = + "homePath" in config && typeof config.homePath === "string" ? config.homePath.trim() : ""; + return native || (driver === "codex" && mode === "managed" ? "~/.codex" : ""); +} + export const deriveProviderInstanceConfigMap = ( settings: ServerSettings, hostEnvironment: NodeJS.ProcessEnv = {}, @@ -119,7 +127,13 @@ export const deriveProviderInstanceConfigMap = ( merged[id] = { ...native, ...(replacesAccounts ? { displayName: proxy.displayName } : {}), - config: { ...native.config, ...proxy.config }, + config: { + ...native.config, + ...proxy.config, + ...(driver === "codex" || driver === "claudeAgent" + ? { inferenceSkillsHomePath: inferenceSkillsHome(driver, route) } + : {}), + }, environment: [ ...(native.environment ?? []).filter((entry) => !names.has(entry.name)), ...proxy.environment, diff --git a/apps/server/src/skills/SkillsLibrary.test.ts b/apps/server/src/skills/SkillsLibrary.test.ts index 67305f17785fc..46e22c1675ad7 100644 --- a/apps/server/src/skills/SkillsLibrary.test.ts +++ b/apps/server/src/skills/SkillsLibrary.test.ts @@ -106,20 +106,27 @@ it.layer(NodeServices.layer)("SkillsLibrary", (it) => { const path = yield* Path.Path; const customHome = yield* fs.makeTempDirectoryScoped({ prefix: "t3-custom-skills-" }); const directory = path.join(customHome, "skills"); - const { service, library, skill, read, link } = yield* setup( + const { service, claude, library, skill, read, link } = yield* setup( [ProviderDriverKind.make("claudeAgent")], { directory, enabled: true }, ); yield* skill(directory, "custom", "custom instructions"); + yield* skill(claude, "personal", "personal instructions"); + yield* skill(library, "personal", "personal instructions"); + yield* fs.symlink(path.join(claude, "personal"), path.join(directory, "personal")); yield* skill(library, "shared", "shared instructions"); yield* service.apply; yield* service.apply; expect(yield* read(library, "custom")).toContain("custom instructions"); expect(yield* read(directory, "shared")).toContain("shared instructions"); expect(yield* link(directory, "custom")).toBe(path.join(library, "custom")); + expect(yield* read(library, "personal")).toContain("personal instructions"); + expect(yield* read(directory, "personal")).toContain("personal instructions"); + expect((yield* service.status).conflicts).toEqual([]); yield* service.detach; expect(yield* link(directory, "custom")).toBeUndefined(); expect(yield* read(directory, "shared")).toContain("shared instructions"); + expect(yield* read(directory, "personal")).toContain("personal instructions"); yield* service.detach; }), ); diff --git a/apps/server/src/skills/SkillsLibrary.ts b/apps/server/src/skills/SkillsLibrary.ts index f03d3d1bb4e25..f4326254c9260 100644 --- a/apps/server/src/skills/SkillsLibrary.ts +++ b/apps/server/src/skills/SkillsLibrary.ts @@ -101,6 +101,7 @@ interface LibraryScan { /** Case-folded names with a conflict; nothing moves for them. */ readonly conflicted: ReadonlySet; readonly copies: ReadonlyMap>; + readonly aliases: ReadonlySet; } const RESTORE_SUFFIX = ".t3-restore"; @@ -403,11 +404,21 @@ export const make = Effect.gen(function* () { if (link !== undefined) conflict({ name, paths: [copy, link], reason: "outsideLink" }); } } + const aliases = new Set(); for (const rootScan of rootScans.filter((root) => root.active)) { for (const name of rootScan.otherLinks) { const first = groups.get(fold(name))?.[0]; if (first !== undefined) { - conflict({ name, paths: [path.join(rootScan.directory, name), first.path] }); + const linkPath = path.join(rootScan.directory, name); + const target = yield* realPath(linkPath).pipe(Effect.orElseSucceed(() => undefined)); + if ( + target !== undefined && + (yield* Effect.forEach(copies.get(name) ?? [], realPath)).includes(target) + ) { + aliases.add(linkPath); + } else { + conflict({ name, paths: [linkPath, first.path] }); + } } } } @@ -427,6 +438,7 @@ export const make = Effect.gen(function* () { conflicts, conflicted, copies, + aliases, } satisfies LibraryScan; }); @@ -477,7 +489,11 @@ export const make = Effect.gen(function* () { const linkPath = path.join(rootScan.directory, name); yield* io("apply", linkPath, () => NodeFSP.unlink(linkPath)); } - const names = linkable.filter((name) => !rootScan.root.private.includes(name)); + const names = linkable.filter( + (name) => + !rootScan.root.private.includes(name) && + !current.aliases.has(path.join(rootScan.directory, name)), + ); yield* materializeHomeOverlay({ sharedRoot: current.libraryPath, accountDir: rootScan.directory, diff --git a/docs/user/composer.md b/docs/user/composer.md index 494ca209dbafb..22afd91520275 100644 --- a/docs/user/composer.md +++ b/docs/user/composer.md @@ -419,6 +419,11 @@ and your next message starts the agent again with the new setup. ### One skills library for every provider +Inference routing uses skills from the machine running the thread, not from the inference +host. OpenCode and Pi keep their usual skill paths. Claude and Codex also pick up personal +skills from their local profiles; a skill installed directly in the routed profile wins if +both have the same name. Turning off **Use your Claude profile** keeps those personal skills private. + Turn on **Settings → Labs → Zack → Skills library** to keep one set of skills for every provider and account on that environment. T3 Code moves each skill folder from `~/.claude/skills`, `~/.codex/skills`, and Antigravity's user skill folders diff --git a/packages/contracts/src/settings.test.ts b/packages/contracts/src/settings.test.ts index 8e78d34ac279b..72016a79bb6c3 100644 --- a/packages/contracts/src/settings.test.ts +++ b/packages/contracts/src/settings.test.ts @@ -593,6 +593,7 @@ describe("machine-local provider settings", () => { it("keeps native paths and inference routes local on Codex", () => { expect(machineLocalSettingsFields(CodexSettings)).toEqual([ ...routingFields, + "inferenceSkillsHomePath", "binaryPath", "homePath", "shadowHomePath", @@ -602,6 +603,7 @@ describe("machine-local provider settings", () => { it("marks home and binary paths on Claude", () => { expect(machineLocalSettingsFields(ClaudeSettings)).toEqual([ ...routingFields, + "inferenceSkillsHomePath", "binaryPath", "homePath", "shareProfile", diff --git a/packages/contracts/src/settings.ts b/packages/contracts/src/settings.ts index 6263ff90a755b..beada6fdc5a0c 100644 --- a/packages/contracts/src/settings.ts +++ b/packages/contracts/src/settings.ts @@ -742,9 +742,15 @@ export function makeProviderSettingsSchema