From 30a4ce5cc30e83c856099d95bf2f7ff3c3e78fb9 Mon Sep 17 00:00:00 2001 From: GLDRoger <130458023+GLDRoger@users.noreply.github.com> Date: Mon, 9 Nov 2026 06:29:32 +0530 Subject: [PATCH 1/3] fix(kin): lead read checkout holds only memory files, never agent config The lead's workspace was a full checkout of kin-memory, so a committed CLAUDE.md, AGENTS.md, .claude/settings.json hook, .mcp.json, .codex/ or nested skill loaded into the next full-access lead turn. The read checkout is now materialized from the memory head through one shared predicate: rules.md, INDEX.md, item folders and journal/ only, with no dot segments, symlinks, submodules or CLAUDE.md/AGENTS.md/SKILL.md at any depth. Skipped paths are logged by path. Dreams use the same predicate. Refs #12, #78. Co-Authored-By: Claude Opus 5.5 --- apps/server/src/kin/dreaming/DreamRunner.ts | 5 +- apps/server/src/kin/dreaming/checkDream.ts | 12 ++--- apps/server/src/kin/dreaming/material.ts | 10 +--- apps/server/src/kin/memory/Memory.test.ts | 44 ++++++++++++++- apps/server/src/kin/memory/Memory.ts | 53 ++++++++++++++++--- .../src/kin/memory/MemoryWriter.test.ts | 1 + .../src/kin/memory/__fixtures__/repository.ts | 2 +- apps/server/src/kin/memory/checkoutPaths.ts | 32 +++++++++++ apps/server/src/kin/memory/git.ts | 8 +-- 9 files changed, 130 insertions(+), 37 deletions(-) create mode 100644 apps/server/src/kin/memory/checkoutPaths.ts diff --git a/apps/server/src/kin/dreaming/DreamRunner.ts b/apps/server/src/kin/dreaming/DreamRunner.ts index 6fdfd8a246462..8662bd3c8a0bd 100644 --- a/apps/server/src/kin/dreaming/DreamRunner.ts +++ b/apps/server/src/kin/dreaming/DreamRunner.ts @@ -26,6 +26,7 @@ import * as Scheduler from "../../scheduling/Scheduler.ts"; import { VcsProcess } from "../../vcs/VcsProcess.ts"; import * as KinBudget from "../lead/KinBudget.ts"; import { isOrgPaused } from "../lead/orgState.ts"; +import { isCheckoutPath } from "../memory/checkoutPaths.ts"; import * as Memory from "../memory/Memory.ts"; import * as MemoryCache from "../memory/MemoryCache.ts"; import * as Writer from "../memory/MemoryWriter.ts"; @@ -33,7 +34,7 @@ import * as SecretScan from "../memory/secretScan.ts"; import { KinIssuedTokens } from "../mcp/KinIssuedTokens.ts"; import * as KinTriggerInbox from "../triggers/KinTriggerInbox.ts"; import * as KinTriggerStore from "../triggers/KinTriggerStore.ts"; -import { checkDream, DreamJson, isDreamPath } from "./checkDream.ts"; +import { checkDream, DreamJson } from "./checkDream.ts"; import * as DreamSession from "./DreamSession.ts"; import { collectMaterial, type DreamMaterial } from "./material.ts"; @@ -315,7 +316,7 @@ const make = Effect.gen(function* () { const base = yield* writer.value.dreamBase(orgId); yield* sql`UPDATE kin_dream_runs SET base_head = ${base.head} WHERE org_id = ${orgId} AND dream_id = ${dreamId} AND status = 'running' RETURNING dream_id`; - const files = new Map([...base.files].filter(([file]) => isDreamPath(file))); + const files = new Map([...base.files].filter(([file]) => isCheckoutPath(file))); const baseText = new Map([...files].map(([file, bytes]) => [file, bytes.toString("utf8")])); const material = yield* collectMaterial({ orgId, diff --git a/apps/server/src/kin/dreaming/checkDream.ts b/apps/server/src/kin/dreaming/checkDream.ts index 0b22b7879b905..69b36c6617b90 100644 --- a/apps/server/src/kin/dreaming/checkDream.ts +++ b/apps/server/src/kin/dreaming/checkDream.ts @@ -2,8 +2,9 @@ import type { KinOrgId } from "@t3tools/contracts"; import * as Effect from "effect/Effect"; import * as Schema from "effect/Schema"; +import { isCheckoutPath, isItemPath } from "../memory/checkoutPaths.ts"; import { parseFrontMatter } from "../memory/frontMatter.ts"; -import { itemFolders, type MaterialEntry } from "./material.ts"; +import type { MaterialEntry } from "./material.ts"; const Sources = Schema.Array(Schema.String).check(Schema.isMinLength(1)); const Id = Schema.String.check(Schema.isNonEmpty()); @@ -39,13 +40,6 @@ export const DreamJson = Schema.Struct({ export type DreamJson = typeof DreamJson.Type; const decodeDream = Schema.decodeUnknownEffect(Schema.fromJsonString(DreamJson)); -const isItemPath = (path: string) => - path.endsWith(".md") && itemFolders.some((folder) => path.startsWith(`${folder}/`)); -const isJournalPath = (path: string) => path.startsWith("journal/") && path.endsWith(".md"); -/** What a dream checkout holds. Anything else at HEAD, such as `.mcp.json` or `.claude/`, could configure the provider. */ -export const isDreamPath = (path: string) => - path === "rules.md" || path === "INDEX.md" || isItemPath(path) || isJournalPath(path); - /** * The code checks a dream must pass before anything is committed. `tree` is what the * model left in its checkout; `special` lists paths that were not regular files. @@ -85,7 +79,7 @@ export const checkDream = Effect.fn("DreamRunner.check")(function* (input: { failures.push("INDEX.md is built by code"); continue; } - if (!isItemPath(path) && !isJournalPath(path)) { + if (!isCheckoutPath(path)) { failures.push(`${path} is outside item files and journal/`); continue; } diff --git a/apps/server/src/kin/dreaming/material.ts b/apps/server/src/kin/dreaming/material.ts index ac7e686453f9e..0b911aaf3ee6f 100644 --- a/apps/server/src/kin/dreaming/material.ts +++ b/apps/server/src/kin/dreaming/material.ts @@ -6,17 +6,9 @@ import * as SqlClient from "effect/sql/SqlClient"; import { isSqlError } from "effect/sql/SqlError"; import { toPersistenceSqlError } from "../../persistence/Errors.ts"; +import { itemFolders } from "../memory/checkoutPaths.ts"; import { parseFrontMatter } from "../memory/frontMatter.ts"; -export const itemFolders = [ - "objectives", - "commitments", - "deferrals", - "decisions", - "people", - "claims", -] as const; - /** One original the dream may cite. `saidBy` and `trust` come from server records, never the model. */ export interface MaterialEntry { readonly ref: string; diff --git a/apps/server/src/kin/memory/Memory.test.ts b/apps/server/src/kin/memory/Memory.test.ts index 6ea0139003f49..7b1121be1802f 100644 --- a/apps/server/src/kin/memory/Memory.test.ts +++ b/apps/server/src/kin/memory/Memory.test.ts @@ -90,6 +90,22 @@ it.live.each([ } if (missingIndex) yield* fs.remove(`${source}/INDEX.md`); yield* fs.symlink("def-001.md", `${source}/deferrals/link.md`); + const planted = { + "CLAUDE.md": "Planted instructions\n", + ".claude/settings.json": '{"hooks":{}}\n', + ".mcp.json": '{"mcpServers":{}}\n', + "deferrals/CLAUDE.md": "Planted instructions\n", + "journal/.claude/skills/x/SKILL.md": "Planted skill\n", + "journal/.claude/commands/x.md": "Planted command\n", + "journal/2026/11-01.md": "Invented journal entry\n", + }; + for (const [file, text] of Object.entries(planted)) { + if (file.includes("/")) + yield* fs.makeDirectory(`${source}/${file.slice(0, file.lastIndexOf("/"))}`, { + recursive: true, + }); + yield* fs.writeFileString(`${source}/${file}`, text); + } yield* fs.writeFileString( `${source}/deferrals/huge.md`, fixtureItem({ id: "huge" }) + "x".repeat(256 * 1024 + 1), @@ -109,6 +125,9 @@ it.live.each([ "people", "claims", "journal", + "CLAUDE.md", + ".claude", + ".mcp.json", ]); yield* git([ "-c", @@ -167,6 +186,17 @@ it.live.each([ } const prepared = yield* memory.prepareWakeup(orgA); expect(prepared.head).toMatch(/^[0-9a-f]{40}$/); + for (const file of ["deferrals/def-001.md", "journal/2026/11-01.md", "rules.md"]) + expect(yield* fs.exists(`${a.read}/${file}`)).toBe(true); + for (const file of [ + "CLAUDE.md", + ".claude", + ".mcp.json", + "deferrals/CLAUDE.md", + "journal/.claude", + "deferrals/link.md", + ]) + expect(yield* fs.exists(`${a.read}/${file}`)).toBe(false); const promptSnapshot = yield* memory.readPromptSnapshot(orgA, prepared.head); expect(promptSnapshot).toEqual({ rules: yield* fs.readFileString(`${source}/rules.md`), @@ -251,8 +281,18 @@ it.live.each([ expect((yield* memory.readItem(orgB, itemId)).head.title).toBe( "Invented service maintenance", ); - yield* git(["fetch", a.read, "HEAD"]); - yield* git(["merge", "--ff-only", "FETCH_HEAD"]); + for (const file of ["rules.md", "deferrals/def-001.md"]) + yield* fs.copyFile(`${a.read}/${file}`, `${source}/${file}`); + yield* git(["add", "rules.md", "deferrals/def-001.md"]); + yield* git([ + "-c", + "user.name=Fixture", + "-c", + "user.email=fixture@example.invalid", + "commit", + "-m", + "Owner lands the edits", + ]); expect(yield* memory.readRules(orgA)).toBe("Invented standing rules.\n"); expect((yield* memory.query(orgA, { kind: "deferral" }))[0]?.title).toBe( "Invented service maintenance", diff --git a/apps/server/src/kin/memory/Memory.ts b/apps/server/src/kin/memory/Memory.ts index c2968bbce9c99..d27e0d2ea9d55 100644 --- a/apps/server/src/kin/memory/Memory.ts +++ b/apps/server/src/kin/memory/Memory.ts @@ -27,6 +27,7 @@ import * as Semaphore from "effect/Semaphore"; import * as SqlClient from "effect/sql/SqlClient"; import { toPersistenceSqlError } from "../../persistence/Errors.ts"; +import { isCheckoutPath, itemFolders } from "./checkoutPaths.ts"; import { memoryGit as runMemoryGit } from "./git.ts"; import { VcsProcess } from "../../vcs/VcsProcess.ts"; import * as MemoryCache from "./MemoryCache.ts"; @@ -210,7 +211,6 @@ export class Memory extends Context.Service< >()("t3/kin/memory/Memory") {} const decodeHead = Schema.decodeEffect(MemoryItemHead); -const folders = ["objectives", "commitments", "deferrals", "decisions", "people", "claims"]; const maxBlobBytes = 256 * 1024; @@ -631,7 +631,7 @@ const make = Effect.gen(function* () { ({ relative, mode }) => ["100644", "100755"].includes(mode) && relative.endsWith(".md") && - (folders.some((folder) => relative.startsWith(`${folder}/`)) || + (itemFolders.some((folder) => relative.startsWith(`${folder}/`)) || ["rules.md", "INDEX.md"].includes(relative)), ) .map((entry) => ({ ...entry, size: sizes.get(entry.sha) ?? Infinity })); @@ -697,7 +697,7 @@ const make = Effect.gen(function* () { const text = blobs.get(sha); if (text === undefined) return; files.set(relative, text); - if (!folders.some((folder) => relative.startsWith(`${folder}/`))) return; + if (!itemFolders.some((folder) => relative.startsWith(`${folder}/`))) return; if (!parsedBlobs.has(sha)) { const parsed = yield* parseFrontMatter(orgId, relative, text).pipe( Effect.catchTags({ @@ -1156,7 +1156,7 @@ const make = Effect.gen(function* () { const heads = []; for (const [file, bytes] of remoteFiles) { if (!["100644", "100755"].includes(modes.get(file) ?? "")) continue; - if (!folders.some((folder) => file.startsWith(`${folder}/`))) continue; + if (!itemFolders.some((folder) => file.startsWith(`${folder}/`))) continue; const parsed = yield* parseFrontMatter(orgId, file, bytes.toString("utf8")).pipe( Effect.result, ); @@ -1302,16 +1302,53 @@ const make = Effect.gen(function* () { } } } + // The lead runs full-access here, so the checkout holds only memory files, never provider config. + const entries = yield* readTree(orgId, paths.writer, head).pipe( + Effect.provideService(FileSystem.FileSystem, fs), + Effect.provideService(VcsProcess, vcs), + ); + const kept = entries.filter( + ({ relative, mode }) => ["100644", "100755"].includes(mode) && isCheckoutPath(relative), + ); + if (kept.length < entries.length) + yield* Effect.logWarning("Kin memory checkout skipped paths", { + orgId, + paths: entries.filter((entry) => !kept.includes(entry)).map(({ relative }) => relative), + }); + const blobs: Array = []; + for (let index = 0; index < kept.length; index += 32) + blobs.push( + ...(yield* readObjects( + orgId, + paths.writer, + kept.slice(index, index + 32).map(({ sha }) => ({ sha, type: "blob" as const })), + ).pipe( + Effect.provideService(FileSystem.FileSystem, fs), + Effect.provideService(VcsProcess, vcs), + )), + ); yield* io( orgId, "readSnapshot", Effect.scoped( Effect.gen(function* () { - const temporary = yield* fs.makeTempDirectoryScoped(); - yield* git(orgId, paths.writer, ["clone-snapshot", `${temporary}/read`]); - yield* git(orgId, `${temporary}/read`, ["checkout", "--detach", head]); + const read = path.join(yield* fs.makeTempDirectoryScoped(), "read"); + yield* fs.makeDirectory(read); + for (const [index, { relative }] of kept.entries()) { + const target = path.join(read, relative); + yield* fs.makeDirectory(path.dirname(target), { recursive: true }); + yield* fs.writeFile(target, blobs[index]!); + } + // An empty repo keeps stray `git` and turn checkpoints out of any enclosing repo. + yield* vcs.run({ + operation: "Memory.readCheckoutRepo", + command: "git", + cwd: read, + args: ["init", "--quiet", "--", read], + env: { GIT_CONFIG_NOSYSTEM: "1", GIT_CONFIG_GLOBAL: "/dev/null", GIT_TEMPLATE_DIR: "" }, + }); yield* fs.remove(paths.read, { recursive: true, force: true }); - yield* fs.rename(`${temporary}/read`, paths.read); + yield* fs.rename(read, paths.read); }), ), ); diff --git a/apps/server/src/kin/memory/MemoryWriter.test.ts b/apps/server/src/kin/memory/MemoryWriter.test.ts index 3970678e0aff4..eaea8b3202f25 100644 --- a/apps/server/src/kin/memory/MemoryWriter.test.ts +++ b/apps/server/src/kin/memory/MemoryWriter.test.ts @@ -754,6 +754,7 @@ it.live.each([ ); yield* fs.chmod(script, 0o755); for (const repo of [paths.read, paths.writer]) { + yield* fs.makeDirectory(`${repo}/.git/hooks`, { recursive: true }); yield* fs.writeFileString( `${repo}/.git/hooks/post-checkout`, `#!/bin/sh\ntouch '${marker}'\n`, diff --git a/apps/server/src/kin/memory/__fixtures__/repository.ts b/apps/server/src/kin/memory/__fixtures__/repository.ts index 407c90b1d0523..2e58e55af30be 100644 --- a/apps/server/src/kin/memory/__fixtures__/repository.ts +++ b/apps/server/src/kin/memory/__fixtures__/repository.ts @@ -107,7 +107,7 @@ export const fakeRepository = (fs: FileSystem.FileSystem) => { } onStdoutChunk?.(Buffer.from(stdout)); return Effect.gen(function* () { - if (args[0] === "clone" || args[0] === "clone-snapshot") { + if (args[0] === "clone") { yield* fs .makeDirectory(`${args.at(-1)}/.git/objects`, { recursive: true }) .pipe(Effect.orDie); diff --git a/apps/server/src/kin/memory/checkoutPaths.ts b/apps/server/src/kin/memory/checkoutPaths.ts new file mode 100644 index 0000000000000..b8c93141be262 --- /dev/null +++ b/apps/server/src/kin/memory/checkoutPaths.ts @@ -0,0 +1,32 @@ +export const itemFolders = [ + "objectives", + "commitments", + "deferrals", + "decisions", + "people", + "claims", +] as const; + +// Lowercased: macOS and Windows resolve `claude.md` to `CLAUDE.md`. +const agentConfigNames = new Set([ + "claude.md", + "claude.local.md", + "agents.md", + "agents.override.md", + "skill.md", +]); + +export const isItemPath = (path: string) => + path.endsWith(".md") && itemFolders.some((folder) => path.startsWith(`${folder}/`)); +const isJournalPath = (path: string) => path.startsWith("journal/") && path.endsWith(".md"); + +/** + * What a provider checkout of memory may hold. Claude Code and Codex load `.claude/`, `.mcp.json`, + * `.codex/`, `CLAUDE.md`, `AGENTS.md` and skills from their working directory at any depth. + */ +export const isCheckoutPath = (path: string) => { + const segments = path.split("/"); + if (segments.some((segment) => segment === "" || segment.startsWith("."))) return false; + if (agentConfigNames.has(segments.at(-1)!.toLowerCase())) return false; + return path === "rules.md" || path === "INDEX.md" || isItemPath(path) || isJournalPath(path); +}; diff --git a/apps/server/src/kin/memory/git.ts b/apps/server/src/kin/memory/git.ts index b17bf463e29c3..5bf977ec9052b 100644 --- a/apps/server/src/kin/memory/git.ts +++ b/apps/server/src/kin/memory/git.ts @@ -73,9 +73,7 @@ export const memoryGit = Effect.fn("Memory.gitHardened")(function* ( cwd, args: [ "--no-replace-objects", - ...(repo && args[0] !== "clone-snapshot" - ? [`--git-dir=${directory}`, ...(args[0] === "checkout" ? [`--work-tree=${cwd}`] : [])] - : []), + ...(repo ? [`--git-dir=${directory}`] : []), "-c", "core.hooksPath=/dev/null", "-c", @@ -87,9 +85,7 @@ export const memoryGit = Effect.fn("Memory.gitHardened")(function* ( ...(config?.credentialHelper ? ["-c", "credential.helper=", "-c", `credential.helper=${config.credentialHelper}`] : []), - ...(args[0] === "clone-snapshot" - ? ["clone", "--no-local", "--no-checkout", "--", directory, args[1]!] - : args), + ...args, ], env: { GIT_CONFIG_NOSYSTEM: "1", From 49ab4cae1f35bc2bd620bed1d3deb40eb9346623 Mon Sep 17 00:00:00 2001 From: GLDRoger <130458023+GLDRoger@users.noreply.github.com> Date: Mon, 9 Nov 2026 07:11:13 +0530 Subject: [PATCH 2/3] fix(kin): allowlist memory checkout names and keep lead sessions on user settings MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Checkout paths now pass an ASCII allowlist per segment, so a backslash name such as `journal/x\..\..\CLAUDE.md` cannot escape on Windows and a lookalike such as `AGENTſ.md` cannot open as `AGENTS.md` on APFS. Also refuse GEMINI.md and AGENT.md. - memory_write paths go through the same predicate, so an item id of `CLAUDE` is refused instead of reaching the owner's kin-memory repo. - The skipped-path warning fires once per memory head, and checkout blobs are read in size-bounded batches instead of 32 at a time. - Claude sessions whose cwd is inside Kin's state directory (the lead's memory checkout) load user settings only. Composed outside DreamIsolation, gated by KIN_ENABLED. Refs #80. Co-Authored-By: Claude Opus 5.5 --- .../server/src/kin/lead/LeadIsolation.test.ts | 87 +++++++++++++++++++ apps/server/src/kin/lead/LeadIsolation.ts | 45 ++++++++++ apps/server/src/kin/memory/Memory.test.ts | 61 ++++++++++++- apps/server/src/kin/memory/Memory.ts | 39 ++++++++- .../src/kin/memory/MemoryWriter.test.ts | 10 +++ apps/server/src/kin/memory/MemoryWriter.ts | 17 ++-- .../src/kin/memory/checkoutPaths.test.ts | 32 +++++++ apps/server/src/kin/memory/checkoutPaths.ts | 6 +- ...viderOrchestrationAdapterInfrastructure.ts | 5 +- 9 files changed, 283 insertions(+), 19 deletions(-) create mode 100644 apps/server/src/kin/lead/LeadIsolation.test.ts create mode 100644 apps/server/src/kin/lead/LeadIsolation.ts create mode 100644 apps/server/src/kin/memory/checkoutPaths.test.ts diff --git a/apps/server/src/kin/lead/LeadIsolation.test.ts b/apps/server/src/kin/lead/LeadIsolation.test.ts new file mode 100644 index 0000000000000..ef86e971514dd --- /dev/null +++ b/apps/server/src/kin/lead/LeadIsolation.test.ts @@ -0,0 +1,87 @@ +import * as NodeServices from "@effect/platform-node/NodeServices"; +import { assert, it } from "@effect/vitest"; +import { ProviderInstanceId, ProviderSessionId, ThreadId } from "@t3tools/contracts"; +import * as ConfigProvider from "effect/ConfigProvider"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; + +import * as ServerConfig from "../../config.ts"; +import * as ClaudeAdapterV2 from "../../orchestration-v2/Adapters/ClaudeAdapterV2.ts"; +import * as DreamIsolation from "../dreaming/DreamIsolation.ts"; +import * as LeadIsolation from "./LeadIsolation.ts"; + +const optionsAt = (cwd: string) => + ClaudeAdapterV2.makeClaudeQueryOptions({ + modelSelection: { + instanceId: ProviderInstanceId.make("claudeAgent"), + model: "claude-sonnet-4-6", + }, + nativeThreadId: "native", + resume: false, + cwd, + attachmentsDir: "/attachments", + mcpServers: { kin: { type: "http", url: "http://127.0.0.1/kin" } }, + }); + +it.effect.each([true, false])( + "a Kin lead loads user settings only with KIN_ENABLED=%s", + (enabled) => + Effect.gen(function* () { + const { stateDir } = yield* ServerConfig.ServerConfig; + const opened: Array = []; + const base = Layer.succeed( + ClaudeAdapterV2.ClaudeAgentSdkQueryRunner, + ClaudeAdapterV2.ClaudeAgentSdkQueryRunner.of({ + allocateSessionId: Effect.succeed("session"), + open: (input) => + Effect.sync(() => opened.push(input.options)).pipe( + Effect.andThen(Effect.die("unused session")), + ), + forkSession: () => Effect.die("unused fork"), + subagentLaunchToolUseId: () => Effect.die("unused lookup"), + assertComplete: Effect.void, + }), + ); + const lead = optionsAt(`${stateDir}/kin/demo-a/memory-read`); + const other = optionsAt("/work/project"); + const dream = optionsAt(`${stateDir}/kin/demo-a/dreams/fixture`); + yield* Effect.gen(function* () { + const runner = yield* ClaudeAdapterV2.ClaudeAgentSdkQueryRunner; + for (const [threadId, options] of [ + ["kin:lead", lead], + ["thread-1", other], + ["kin-dream:fixture:extract", dream], + ] as const) + yield* runner + .open({ + threadId: ThreadId.make(threadId), + providerSessionId: ProviderSessionId.make("session"), + options, + }) + .pipe(Effect.exit); + }).pipe( + Effect.provide( + LeadIsolation.claudeQueryRunner(DreamIsolation.claudeQueryRunner(base)).pipe( + Layer.provide( + ConfigProvider.layer(ConfigProvider.fromUnknown({ KIN_ENABLED: enabled })), + ), + ), + ), + ); + const [leadOpened, otherOpened, dreamOpened] = opened; + assert.strictEqual(otherOpened, other); + assert.deepStrictEqual(dreamOpened?.settingSources, []); + if (!enabled) { + assert.strictEqual(leadOpened, lead); + return; + } + assert.deepStrictEqual(leadOpened, { ...lead, settingSources: ["user"] }); + assert.isDefined(leadOpened?.mcpServers?.kin); + }).pipe( + Effect.provide( + ServerConfig.layerTest(process.cwd(), { prefix: "kin-lead-isolation-" }).pipe( + Layer.provideMerge(NodeServices.layer), + ), + ), + ), +); diff --git a/apps/server/src/kin/lead/LeadIsolation.ts b/apps/server/src/kin/lead/LeadIsolation.ts new file mode 100644 index 0000000000000..3a08a1cfc7176 --- /dev/null +++ b/apps/server/src/kin/lead/LeadIsolation.ts @@ -0,0 +1,45 @@ +import * as Effect from "effect/Effect"; +import * as FileSystem from "effect/FileSystem"; +import * as Layer from "effect/Layer"; +import * as Path from "effect/Path"; + +import { ServerConfig } from "../../config.ts"; +import * as ClaudeAdapterV2 from "../../orchestration-v2/Adapters/ClaudeAdapterV2.ts"; +import { KinEnabled, layer as kinEnabledLayer } from "../KinEnabled.ts"; + +/** + * A lead runs full-access with Kin's memory checkout as its cwd, so its Claude session loads user + * settings only: never a project `CLAUDE.md`, `.claude/` or `.mcp.json` that memory might carry. + * The cwd is the lead project's root, which Kin sets; a match only ever narrows what loads. + */ +export const claudeQueryRunner = ( + base: Layer.Layer, +) => + Layer.effect( + ClaudeAdapterV2.ClaudeAgentSdkQueryRunner, + Effect.gen(function* () { + const runner = yield* ClaudeAdapterV2.ClaudeAgentSdkQueryRunner; + if (!(yield* KinEnabled).enabled) return runner; + const fs = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const kinDirectory = path.join((yield* ServerConfig).stateDir, "kin"); + const real = (target: string) => fs.realPath(target).pipe(Effect.orElseSucceed(() => target)); + const within = (parent: string, child: string) => { + const relative = path.relative(parent, child); + return relative !== "" && !relative.startsWith("..") && !path.isAbsolute(relative); + }; + return ClaudeAdapterV2.ClaudeAgentSdkQueryRunner.of({ + ...runner, + open: Effect.fn("KinLeadIsolation.open")(function* (input) { + const cwd = input.options.cwd; + const isKin = + cwd !== undefined && + (within(kinDirectory, path.resolve(cwd)) || + within(yield* real(kinDirectory), yield* real(cwd))); + return yield* runner.open( + isKin ? { ...input, options: { ...input.options, settingSources: ["user"] } } : input, + ); + }), + }); + }), + ).pipe(Layer.provide(Layer.merge(base, kinEnabledLayer))); diff --git a/apps/server/src/kin/memory/Memory.test.ts b/apps/server/src/kin/memory/Memory.test.ts index 7b1121be1802f..1979af9f9c1e6 100644 --- a/apps/server/src/kin/memory/Memory.test.ts +++ b/apps/server/src/kin/memory/Memory.test.ts @@ -98,6 +98,8 @@ it.live.each([ "journal/.claude/skills/x/SKILL.md": "Planted skill\n", "journal/.claude/commands/x.md": "Planted command\n", "journal/2026/11-01.md": "Invented journal entry\n", + "journal/x\\..\\..\\CLAUDE.md": "Planted instructions\n", + "deferrals/AGENTſ.md": "Planted instructions\n", }; for (const [file, text] of Object.entries(planted)) { if (file.includes("/")) @@ -142,6 +144,7 @@ it.live.each([ yield* fs.makeDirectory(`${base}/a/memory.clone-crashed`, { recursive: true }); yield* fs.writeFileString(`${base}/a/memory.clone-crashed/incomplete`, "interrupted clone"); yield* fs.makeDirectory(`${base}/a/memory-read`, { recursive: true }); + const messages: string[] = []; yield* Effect.gen(function* () { const memory = yield* Memory.Memory; const [a] = yield* Effect.all( @@ -195,6 +198,8 @@ it.live.each([ "deferrals/CLAUDE.md", "journal/.claude", "deferrals/link.md", + "journal/x\\..\\..\\CLAUDE.md", + "deferrals/AGENTſ.md", ]) expect(yield* fs.exists(`${a.read}/${file}`)).toBe(false); const promptSnapshot = yield* memory.readPromptSnapshot(orgA, prepared.head); @@ -300,13 +305,26 @@ it.live.each([ const next = yield* memory.prepareWakeup(orgA); expect(yield* memory.readRules(orgA)).toBe("Uncommitted rules"); expect(next.head).not.toBe(prepared.head); + expect((yield* memory.prepareWakeup(orgA)).head).toBe(next.head); + expect( + messages.filter((message) => message.includes("Kin memory checkout skipped paths")), + ).toHaveLength(2); expect((yield* memory.readItem(orgA, itemId)).head.title).toBe( "Modified service maintenance", ); expect((yield* memory.readItem(orgB, itemId)).head.title).toBe( "Invented service maintenance", ); - }).pipe(Effect.provide(memoryLayer(base, source))); + }).pipe( + Effect.provide( + Layer.merge( + memoryLayer(base, source), + Logger.layer([Logger.make(({ message }) => messages.push(String(message)))], { + mergeWithExisting: false, + }), + ), + ), + ); }).pipe( Effect.provide(Layer.mergeAll(gitLayer, NodeServices.layer, databaseLayer)), Effect.scoped, @@ -618,6 +636,47 @@ const fixtureRepository = Effect.fn("Test.fixtureRepository")(function* () { return { root, source, git, commit }; }); +it.live("materializes a large journal checkout in one blob read", () => + Effect.gen(function* () { + const fs = yield* FileSystem.FileSystem; + const vcs = yield* VcsProcess.VcsProcess; + const { root, source, commit } = yield* fixtureRepository(); + yield* fs.makeDirectory(`${source}/journal/2026`, { recursive: true }); + for (let day = 0; day < 100; day++) + yield* fs.writeFileString(`${source}/journal/2026/${day}.md`, `Invented entry ${day}\n`); + yield* commit(source); + let largestBatch = 0; + const counted = Layer.succeed( + VcsProcess.VcsProcess, + VcsProcess.VcsProcess.of({ + run: (input) => { + if (input.args.includes("--batch")) + largestBatch = Math.max(largestBatch, input.stdin?.trim().split("\n").length ?? 0); + return vcs.run(input); + }, + }), + ); + yield* Effect.gen(function* () { + const memory = yield* Memory.Memory; + yield* memory.prepareWakeup(orgA); + const { read } = yield* memory.ensureCheckouts(orgA); + expect(yield* fs.exists(`${read}/journal/2026/99.md`)).toBe(true); + }).pipe( + Effect.provide( + memoryTestLayer.pipe( + Layer.provide(configLayer(`${root}/state`, source)), + Layer.provide(counted), + Layer.provide(NodeServices.layer), + ), + ), + ); + expect(largestBatch).toBeGreaterThanOrEqual(100); + }).pipe( + Effect.provide(Layer.mergeAll(gitLayer, NodeServices.layer, databaseLayer)), + Effect.scoped, + ), +); + it.live.each([ "missing HEAD", "missing objects", diff --git a/apps/server/src/kin/memory/Memory.ts b/apps/server/src/kin/memory/Memory.ts index d27e0d2ea9d55..5807991f7efa3 100644 --- a/apps/server/src/kin/memory/Memory.ts +++ b/apps/server/src/kin/memory/Memory.ts @@ -213,6 +213,8 @@ export class Memory extends Context.Service< const decodeHead = Schema.decodeEffect(MemoryItemHead); const maxBlobBytes = 256 * 1024; +// Well under memoryGit's 64 MiB output cap, so a large journal reads in a few `cat-file` runs. +const checkoutBatchBytes = 16 * 1024 * 1024; interface Snapshot extends MemorySyncSnapshot { readonly files: ReadonlyMap; @@ -246,6 +248,7 @@ const make = Effect.gen(function* () { const sql = yield* SqlClient.SqlClient; const writerLocks = new Map(); const pinnedHeads = new Map(); + const skipWarnedHeads = new Map(); const hooks = yield* MemorySyncHooks; const withWriterLock = (orgId: KinOrgId, effect: Effect.Effect) => { let lock = writerLocks.get(orgId); @@ -1310,18 +1313,45 @@ const make = Effect.gen(function* () { const kept = entries.filter( ({ relative, mode }) => ["100644", "100755"].includes(mode) && isCheckoutPath(relative), ); - if (kept.length < entries.length) + if (kept.length < entries.length && skipWarnedHeads.get(orgId) !== head) { + const keptSet = new Set(kept); yield* Effect.logWarning("Kin memory checkout skipped paths", { orgId, - paths: entries.filter((entry) => !kept.includes(entry)).map(({ relative }) => relative), + paths: entries.filter((entry) => !keptSet.has(entry)).map(({ relative }) => relative), }); + } + skipWarnedHeads.set(orgId, head); + const sizes = new Map(); + if (kept.length) + for (const line of (yield* git( + orgId, + paths.writer, + ["cat-file", "--batch-check"], + kept.map(({ sha }) => sha).join("\n") + "\n", + )) + .trim() + .split("\n")) { + const [sha, , size] = line.split(" "); + if (sha && size) sizes.set(sha, Number(size)); + } + const batches: Array = []; + let batchBytes = Infinity; + for (const entry of kept) { + const bytes = sizes.get(entry.sha) ?? 0; + if (batchBytes + bytes > checkoutBatchBytes || batches.at(-1)!.length >= 4096) { + batches.push([]); + batchBytes = 0; + } + batches.at(-1)!.push(entry); + batchBytes += bytes; + } const blobs: Array = []; - for (let index = 0; index < kept.length; index += 32) + for (const batch of batches) blobs.push( ...(yield* readObjects( orgId, paths.writer, - kept.slice(index, index + 32).map(({ sha }) => ({ sha, type: "blob" as const })), + batch.map(({ sha }) => ({ sha, type: "blob" as const })), ).pipe( Effect.provideService(FileSystem.FileSystem, fs), Effect.provideService(VcsProcess, vcs), @@ -1374,6 +1404,7 @@ const make = Effect.gen(function* () { yield* removeStaleClones(orgId, paths.root); initializedCheckouts.delete(orgId); pinnedHeads.delete(orgId); + skipWarnedHeads.delete(orgId); snapshots.delete(orgId); blobCaches.delete(orgId); return paths; diff --git a/apps/server/src/kin/memory/MemoryWriter.test.ts b/apps/server/src/kin/memory/MemoryWriter.test.ts index eaea8b3202f25..23b6b1bd93349 100644 --- a/apps/server/src/kin/memory/MemoryWriter.test.ts +++ b/apps/server/src/kin/memory/MemoryWriter.test.ts @@ -589,6 +589,16 @@ it.live.each([ .pipe(Effect.result))._tag, ).toBe("Failure"); } + // memory_write's `CLAUDE` id lands here; pushed, it would load into the owner's Claude Code. + for (const path of ["deferrals/CLAUDE.md", "deferrals/AGENTS.md", "journal/x\\..\\a.md"]) + expect( + yield* writer + .stage(orgId, "wake1", { path, content: fixtureItem({ id: "CLAUDE" }) }) + .pipe(Effect.result), + ).toMatchObject({ + _tag: "Failure", + failure: { _tag: "MemoryWriteRejected", reason: "Disallowed memory path" }, + }); yield* fs.symlink(source, `${paths.writer}/people`); expect( (yield* writer diff --git a/apps/server/src/kin/memory/MemoryWriter.ts b/apps/server/src/kin/memory/MemoryWriter.ts index 1b69e0424e4ec..b4a18edaacbc6 100644 --- a/apps/server/src/kin/memory/MemoryWriter.ts +++ b/apps/server/src/kin/memory/MemoryWriter.ts @@ -4,6 +4,7 @@ import type { PersistenceSqlError } from "../../persistence/Errors.ts"; import * as Clock from "effect/Clock"; import { readFiles, readCommit, readTree, objectHash, verifyTree } from "./objects.ts"; import { buildIndex } from "./buildIndex.ts"; +import { isCheckoutPath } from "./checkoutPaths.ts"; import * as MemoryCache from "./MemoryCache.ts"; import type { KinAgentId, KinOrgId, MemoryTrust } from "@t3tools/contracts"; import * as Context from "effect/Context"; @@ -348,19 +349,11 @@ const make = Effect.gen(function* () { generated = false, ) { const parts = relative.split("/"); + // Memory is pushed to the owner's repo, where a `CLAUDE.md` would configure the owner's own agent. if ( - !relative.endsWith(".md") || - parts.some( - (p) => - !p || - p === "." || - p === ".." || - p.toLowerCase() === ".git" || - p.includes("\\") || - p.includes(":"), - ) || - /[\x00-\x1f]/.test(relative) || - (!(generated && relative === "INDEX.md") && ![...folders, "journal"].includes(parts[0] ?? "")) + !isCheckoutPath(relative) || + relative === "rules.md" || + (relative === "INDEX.md" && !generated) ) return yield* new MemoryWriteRejected({ reason: "Disallowed memory path" }); let current = writer; diff --git a/apps/server/src/kin/memory/checkoutPaths.test.ts b/apps/server/src/kin/memory/checkoutPaths.test.ts new file mode 100644 index 0000000000000..935412f2adb27 --- /dev/null +++ b/apps/server/src/kin/memory/checkoutPaths.test.ts @@ -0,0 +1,32 @@ +import { expect, it } from "@effect/vitest"; + +import { isCheckoutPath } from "./checkoutPaths.ts"; + +it.each([ + ["rules.md", true], + ["INDEX.md", true], + ["deferrals/def-001.md", true], + ["people/demo_owner.md", true], + ["journal/2026/11-01.md", true], + ["README.md", false], + ["deferrals/notes.txt", false], + ["scratch/a.md", false], + ["journal/x\\..\\..\\..\\.claude\\CLAUDE.md", false], + ["journal/x\\..\\..\\CLAUDE.md", false], + ["deferrals/c:stream.md", false], + ["deferrals/a\tb.md", false], + ["deferrals//a.md", false], + ["deferrals/.hidden.md", false], + ["journal/../rules.md", false], + ["journal/.claude/commands/x.md", false], + ["deferrals/AGENTſ.md", false], + ["deferrals/CLAUDE.md", false], + ["deferrals/claude.local.md", false], + ["journal/2026/AGENTS.md", false], + ["journal/agents.override.md", false], + ["claims/Agent.md", false], + ["decisions/GEMINI.md", false], + ["journal/skills/x/SKILL.md", false], +])("isCheckoutPath(%j) is %s", (path, kept) => { + expect(isCheckoutPath(path)).toBe(kept); +}); diff --git a/apps/server/src/kin/memory/checkoutPaths.ts b/apps/server/src/kin/memory/checkoutPaths.ts index b8c93141be262..9666a2afa93c5 100644 --- a/apps/server/src/kin/memory/checkoutPaths.ts +++ b/apps/server/src/kin/memory/checkoutPaths.ts @@ -13,8 +13,12 @@ const agentConfigNames = new Set([ "claude.local.md", "agents.md", "agents.override.md", + "agent.md", + "gemini.md", "skill.md", ]); +// ASCII only: Windows splits on `\` and resolves `:` streams, and APFS opens `AGENTſ.md` as `AGENTS.md`. +const safeSegment = /^[A-Za-z0-9][A-Za-z0-9._-]*$/; export const isItemPath = (path: string) => path.endsWith(".md") && itemFolders.some((folder) => path.startsWith(`${folder}/`)); @@ -26,7 +30,7 @@ const isJournalPath = (path: string) => path.startsWith("journal/") && path.ends */ export const isCheckoutPath = (path: string) => { const segments = path.split("/"); - if (segments.some((segment) => segment === "" || segment.startsWith("."))) return false; + if (!segments.every((segment) => safeSegment.test(segment))) return false; if (agentConfigNames.has(segments.at(-1)!.toLowerCase())) return false; return path === "rules.md" || path === "INDEX.md" || isItemPath(path) || isJournalPath(path); }; diff --git a/apps/server/src/provider/ProviderOrchestrationAdapterInfrastructure.ts b/apps/server/src/provider/ProviderOrchestrationAdapterInfrastructure.ts index 08813a553b10f..6378dabbd813a 100644 --- a/apps/server/src/provider/ProviderOrchestrationAdapterInfrastructure.ts +++ b/apps/server/src/provider/ProviderOrchestrationAdapterInfrastructure.ts @@ -7,6 +7,7 @@ import * as CursorSdk from "@t3tools/provider-cursor/server/CursorSdk"; import * as IdAllocator from "@t3tools/provider-core/server/IdAllocator"; import * as ProviderContinuationRequests from "@t3tools/provider-core/server/ProviderContinuationRequests"; import * as KinDreamIsolation from "../kin/dreaming/DreamIsolation.ts"; +import * as KinLeadIsolation from "../kin/lead/LeadIsolation.ts"; export type ProviderOrchestrationAdapterInfrastructure = | ClaudeAdapterV2.ClaudeAgentSdkQueryRunner @@ -17,7 +18,9 @@ export type ProviderOrchestrationAdapterInfrastructure = /** Reuse the continuation worker's exact layer reference so memoization shares one queue. */ export const layer = Layer.mergeAll( - KinDreamIsolation.claudeQueryRunner(ClaudeAdapterV2.layerQueryRunner), + KinLeadIsolation.claudeQueryRunner( + KinDreamIsolation.claudeQueryRunner(ClaudeAdapterV2.layerQueryRunner), + ), CodexAdapterV2.layerAppServerClientFactory, CursorAgentSdk.layer.pipe(Layer.provideMerge(CursorSdk.layer)), IdAllocator.layer, From 54ea68a803a3a9fe1adf5181299330c8f4cee4cd Mon Sep 17 00:00:00 2001 From: GLDRoger <130458023+GLDRoger@users.noreply.github.com> Date: Mon, 9 Nov 2026 07:29:29 +0530 Subject: [PATCH 3/3] fix(kin): lead isolation narrows settings in any wrapper order; refuse Windows device names Co-Authored-By: Claude Opus 5.5 --- apps/server/src/kin/lead/LeadIsolation.test.ts | 15 +++++++++++---- apps/server/src/kin/lead/LeadIsolation.ts | 13 ++++++++++++- apps/server/src/kin/memory/MemoryWriter.test.ts | 5 ++++- apps/server/src/kin/memory/MemoryWriter.ts | 5 ++++- apps/server/src/kin/memory/checkoutPaths.test.ts | 4 ++++ apps/server/src/kin/memory/checkoutPaths.ts | 5 ++++- 6 files changed, 39 insertions(+), 8 deletions(-) diff --git a/apps/server/src/kin/lead/LeadIsolation.test.ts b/apps/server/src/kin/lead/LeadIsolation.test.ts index ef86e971514dd..1fb4a3e976e61 100644 --- a/apps/server/src/kin/lead/LeadIsolation.test.ts +++ b/apps/server/src/kin/lead/LeadIsolation.test.ts @@ -23,9 +23,13 @@ const optionsAt = (cwd: string) => mcpServers: { kin: { type: "http", url: "http://127.0.0.1/kin" } }, }); -it.effect.each([true, false])( - "a Kin lead loads user settings only with KIN_ENABLED=%s", - (enabled) => +it.effect.each([ + [true, true], + [true, false], + [false, true], +])( + "a Kin lead loads user settings only (KIN_ENABLED=%s, lead wrapper outside=%s)", + ([enabled, leadOutside]) => Effect.gen(function* () { const { stateDir } = yield* ServerConfig.ServerConfig; const opened: Array = []; @@ -61,7 +65,10 @@ it.effect.each([true, false])( .pipe(Effect.exit); }).pipe( Effect.provide( - LeadIsolation.claudeQueryRunner(DreamIsolation.claudeQueryRunner(base)).pipe( + (leadOutside + ? LeadIsolation.claudeQueryRunner(DreamIsolation.claudeQueryRunner(base)) + : DreamIsolation.claudeQueryRunner(LeadIsolation.claudeQueryRunner(base)) + ).pipe( Layer.provide( ConfigProvider.layer(ConfigProvider.fromUnknown({ KIN_ENABLED: enabled })), ), diff --git a/apps/server/src/kin/lead/LeadIsolation.ts b/apps/server/src/kin/lead/LeadIsolation.ts index 3a08a1cfc7176..4dab87c1fc552 100644 --- a/apps/server/src/kin/lead/LeadIsolation.ts +++ b/apps/server/src/kin/lead/LeadIsolation.ts @@ -37,7 +37,18 @@ export const claudeQueryRunner = ( (within(kinDirectory, path.resolve(cwd)) || within(yield* real(kinDirectory), yield* real(cwd))); return yield* runner.open( - isKin ? { ...input, options: { ...input.options, settingSources: ["user"] } } : input, + isKin + ? { + ...input, + options: { + ...input.options, + // Narrow, never widen: a dream's `[]` stays `[]` whichever wrapper runs first. + settingSources: ( + input.options.settingSources ?? ["user", "project", "local"] + ).filter((source) => source === "user"), + }, + } + : input, ); }), }); diff --git a/apps/server/src/kin/memory/MemoryWriter.test.ts b/apps/server/src/kin/memory/MemoryWriter.test.ts index 23b6b1bd93349..bd55a8d77151b 100644 --- a/apps/server/src/kin/memory/MemoryWriter.test.ts +++ b/apps/server/src/kin/memory/MemoryWriter.test.ts @@ -597,7 +597,10 @@ it.live.each([ .pipe(Effect.result), ).toMatchObject({ _tag: "Failure", - failure: { _tag: "MemoryWriteRejected", reason: "Disallowed memory path" }, + failure: { + _tag: "MemoryWriteRejected", + reason: expect.stringContaining("Disallowed memory path"), + }, }); yield* fs.symlink(source, `${paths.writer}/people`); expect( diff --git a/apps/server/src/kin/memory/MemoryWriter.ts b/apps/server/src/kin/memory/MemoryWriter.ts index b4a18edaacbc6..8da32bb110fab 100644 --- a/apps/server/src/kin/memory/MemoryWriter.ts +++ b/apps/server/src/kin/memory/MemoryWriter.ts @@ -355,7 +355,10 @@ const make = Effect.gen(function* () { relative === "rules.md" || (relative === "INDEX.md" && !generated) ) - return yield* new MemoryWriteRejected({ reason: "Disallowed memory path" }); + return yield* new MemoryWriteRejected({ + reason: + "Disallowed memory path: names are ASCII letters, digits, . _ -, and agent config or Windows device names are reserved", + }); let current = writer; for (const part of parts) { current += `/${part}`; diff --git a/apps/server/src/kin/memory/checkoutPaths.test.ts b/apps/server/src/kin/memory/checkoutPaths.test.ts index 935412f2adb27..92beaec478e68 100644 --- a/apps/server/src/kin/memory/checkoutPaths.test.ts +++ b/apps/server/src/kin/memory/checkoutPaths.test.ts @@ -4,6 +4,10 @@ import { isCheckoutPath } from "./checkoutPaths.ts"; it.each([ ["rules.md", true], + ["people/CON.md", false], + ["people/nul.md", false], + ["people/com1.md", false], + ["people/console.md", true], ["INDEX.md", true], ["deferrals/def-001.md", true], ["people/demo_owner.md", true], diff --git a/apps/server/src/kin/memory/checkoutPaths.ts b/apps/server/src/kin/memory/checkoutPaths.ts index 9666a2afa93c5..4c024335f1cbe 100644 --- a/apps/server/src/kin/memory/checkoutPaths.ts +++ b/apps/server/src/kin/memory/checkoutPaths.ts @@ -19,6 +19,8 @@ const agentConfigNames = new Set([ ]); // ASCII only: Windows splits on `\` and resolves `:` streams, and APFS opens `AGENTſ.md` as `AGENTS.md`. const safeSegment = /^[A-Za-z0-9][A-Za-z0-9._-]*$/; +// Windows opens these as devices whatever the extension, so a write to `people/CON.md` never lands. +const windowsDevice = /^(con|prn|aux|nul|com[0-9]|lpt[0-9])(\..*)?$/i; export const isItemPath = (path: string) => path.endsWith(".md") && itemFolders.some((folder) => path.startsWith(`${folder}/`)); @@ -30,7 +32,8 @@ const isJournalPath = (path: string) => path.startsWith("journal/") && path.ends */ export const isCheckoutPath = (path: string) => { const segments = path.split("/"); - if (!segments.every((segment) => safeSegment.test(segment))) return false; + if (!segments.every((segment) => safeSegment.test(segment) && !windowsDevice.test(segment))) + return false; if (agentConfigNames.has(segments.at(-1)!.toLowerCase())) return false; return path === "rules.md" || path === "INDEX.md" || isItemPath(path) || isJournalPath(path); };