diff --git a/.github/workflows/lazurio-fork-ci.yml b/.github/workflows/lazurio-fork-ci.yml index 7fcbb46a86ba0..435d2bfb278f0 100644 --- a/.github/workflows/lazurio-fork-ci.yml +++ b/.github/workflows/lazurio-fork-ci.yml @@ -69,7 +69,8 @@ jobs: # gives a thread's agents its agent-browser session, the `t3` command following the # version the launcher activated, Buddy's instance without T3's instructions, model or # effort where it builds its provider instances, one request namespace for the agent - # commands' MCP sessions, and no checkpoints in Buddy's project), ws.ts (the managed + # commands' MCP sessions, no checkpoints in Buddy's project, and nothing linking into + # a Personal Environment, row 38), ws.ts (the managed # Folder's config and Buddy's surface for clients, a dispatch run as the session that # sent it, and no ChatGPT handoff on a Lazurio Environment), index.html # (the shell slot, the name in the app, and the composer's room for Buddy's launcher), @@ -304,10 +305,9 @@ jobs: # Buddy's one conversation (root decision 0210, plan DEV-6676): Buddy's T3 Code is one # thread in Buddy's layer of the Lazurio Folder, its managed Folder. The server refuses # forks, rollbacks and any other thread (runtimeLayer.ts, above), takes no checkpoints - # in Buddy's project and keeps linked Environments off (server.ts, above, and the - # settings `t3 environment` builds for itself, cli/environment.ts), applies Buddy's - # defaults once at startup (serverRuntimeStartup.ts, above) and tells clients (ws.ts and - # the contracts' server.ts, above). The web shows Buddy's surface in place of T3's + # in Buddy's project (server.ts, above), applies Buddy's defaults once at startup + # (serverRuntimeStartup.ts, above) and tells clients (ws.ts and the contracts' + # server.ts, above). The web shows Buddy's surface in place of T3's # sidebar and command palette (__root.tsx) and opens Buddy's thread at `/` # (_chat.index.tsx); the chat route's shortcuts, which v0.1.3 installs at app start # (#25366), are off there (shortcuts/chatRouteCommands.ts), and so is upstream's guest @@ -319,7 +319,6 @@ jobs: # (timelineRowContext.ts) and the assistant row's meta leaves the fork out # (TimelineAssistantRows.tsx). avatar.webp is Buddy's character from the design system. # Its code lives in apps/*/src/lazurio/ (buddySurface* and BuddySurface.tsx). - apps/server/src/cli/environment.ts apps/web/public/assets/avatar.webp apps/web/src/components/chat/TimelineAssistantRows.tsx apps/web/src/components/chat/timelineRowContext.ts diff --git a/apps/server/src/cli/environment.ts b/apps/server/src/cli/environment.ts index eae4116147c00..7d7e35b0bea20 100644 --- a/apps/server/src/cli/environment.ts +++ b/apps/server/src/cli/environment.ts @@ -16,7 +16,6 @@ import * as ServerConfig from "../config.ts"; import * as ServerEnvironment from "../environment/ServerEnvironment.ts"; import * as PeerLinks from "../peer/PeerLinks.ts"; import * as ServerSettings from "../serverSettings.ts"; -import * as LazurioBuddyGuards from "../lazurio/buddySurfaceGuards.ts"; import * as ManagedPolicy from "../policy/ManagedPolicy.ts"; import * as SqlitePersistence from "../persistence/Sqlite.ts"; import { authLocationFlags, type CliAuthLocationFlags, resolveCliAuthConfig } from "./config.ts"; @@ -45,7 +44,7 @@ const runWithPeerLinks = Effect.fn("environment.runWithPeerLinks")(function* { ); }); }); - -describe("linked Environments in Buddy's T3 Code", () => { - const linkedOn = () => - withoutLinkedEnvironments(ServerSettings.layerTest({ linkedEnvironmentsEnabled: true })); - const read = Effect.gen(function* () { - const settings = yield* ServerSettings.ServerSettingsService; - return [ - (yield* settings.getSettings).linkedEnvironmentsEnabled, - (yield* settings.updateSettings({ linkedEnvironmentsEnabled: true })) - .linkedEnvironmentsEnabled, - yield* settings.withSettingsSnapshot((current) => - Effect.succeed(current.linkedEnvironmentsEnabled), - ), - ]; - }); - - it.effect("are off, also when the stored settings turn them on", () => { - const { home } = makeHome(); - return Effect.gen(function* () { - assert.deepStrictEqual(yield* read, [false, false, false]); - }).pipe( - Effect.provide(linkedOn()), - Effect.provideService(HostProcess.Environment, { HOME: home, T3CODE_LAZURIO_BUDDY: "1" }), - ); - }); - - // `t3 environment` reads the stored settings, also without the switch in its environment. - it.effect("are stored off by every write, the startup's defaults included", () => { - const { home } = makeHome(); - return Effect.gen(function* () { - const stored = yield* ServerSettings.ServerSettingsService.pipe( - Effect.provide(ServerSettings.layerTest({ linkedEnvironmentsEnabled: true })), - ); - const written: Array = []; - const guarded = yield* ServerSettings.ServerSettingsService.pipe( - Effect.provide( - withoutLinkedEnvironments( - Layer.succeed(ServerSettings.ServerSettingsService, { - ...stored, - updateSettingsWith: (apply) => - Effect.map(stored.getSettings, (current) => { - const next = apply(current); - written.push(next.linkedEnvironmentsEnabled); - return next; - }), - }), - ), - ), - ); - yield* guarded.updateSettingsWith!((current) => current); - yield* guarded.updateSettings({ linkedEnvironmentsEnabled: true }); - assert.deepStrictEqual(written, [false]); - assert.isFalse((yield* stored.getSettings).linkedEnvironmentsEnabled); - }).pipe( - Effect.provideService(HostProcess.Environment, { HOME: home, T3CODE_LAZURIO_BUDDY: "1" }), - ); - }); - - // Clients learn of the administrator's policy from this field; dropping it unlocks their controls. - it.effect("keep the administrator's policy summary", () => { - const { home } = makeHome(); - const policy = { organization: "Example", lockedSettings: ["providers.codex.enabled"] }; - return Effect.gen(function* () { - const settings = yield* ServerSettings.ServerSettingsService; - assert.deepStrictEqual(settings.managedPolicy, policy); - }).pipe( - Effect.provide( - withoutLinkedEnvironments( - ServerSettings.layerTest({ linkedEnvironmentsEnabled: true }, policy), - ), - ), - Effect.provideService(HostProcess.Environment, { HOME: home, T3CODE_LAZURIO_BUDDY: "1" }), - ); - }); - - it.effect("are upstream's outside Buddy's T3 Code", () => { - const { home } = makeHome(); - return Effect.gen(function* () { - assert.deepStrictEqual(yield* read, [true, true, true]); - }).pipe( - Effect.provide(linkedOn()), - Effect.provideService(HostProcess.Environment, { HOME: home }), - ); - }); -}); diff --git a/apps/server/src/lazurio/buddySurfaceGuards.ts b/apps/server/src/lazurio/buddySurfaceGuards.ts index e3006f400b61b..fbd0f8c396c8a 100644 --- a/apps/server/src/lazurio/buddySurfaceGuards.ts +++ b/apps/server/src/lazurio/buddySurfaceGuards.ts @@ -1,19 +1,16 @@ /** - * Lazurio overlay (root decision 0210, plan DEV-6676): Buddy's T3 Code has no fork, rollback, other - * thread, fresh session or deleting Buddy's thread (each loses Hermes's session), no lower runtime - * mode, no guest share or linked Environment (a Personalspace is never shared, 0091) and no + * Lazurio overlay (root decision 0210): Buddy's T3 Code has no fork, rollback, other thread, fresh + * session or deleting Buddy's thread, no lower runtime mode, no guest share (0091) and no * checkpoints in Buddy's project, for every client and agent; elsewhere upstream's services as is. */ -import type { OrchestrationV2ServerCommand, ServerSettings as Settings } from "@t3tools/contracts"; +import type { OrchestrationV2ServerCommand } from "@t3tools/contracts"; import * as HostProcess from "@t3tools/shared/HostProcess"; import * as Effect from "effect/Effect"; import * as Layer from "effect/Layer"; import * as Path from "effect/Path"; -import * as Stream from "effect/Stream"; import * as CheckpointStore from "../checkpointing/CheckpointStore.ts"; import * as Orchestrator from "../orchestration-v2/Orchestrator.ts"; -import * as ServerSettings from "../serverSettings.ts"; import { buddyProjectFolder, isBuddySurfaceEnvironment } from "./buddySurface.ts"; import { BUDDY_THREAD_CREATE_COMMAND_ID, @@ -112,65 +109,3 @@ export const withoutBuddyCheckpoints = ( }); }), ).pipe(Layer.provide(live)); - -/** - * Every upstream gate of linked Environments (peer-link OAuth, a linked client's `/mcp`, outbound - * links, link requests, remote tasks) reads this setting, so Buddy's reads it off whatever is stored - * and every write stores it off. - */ -export const withoutLinkedEnvironments = ( - live: Layer.Layer, -) => - Layer.effect( - ServerSettings.ServerSettingsService, - Effect.gen(function* () { - const settings = yield* ServerSettings.ServerSettingsService; - if (!isBuddySurfaceEnvironment(yield* HostProcess.Environment)) return settings; - const off = (current: Settings): Settings => ({ - ...current, - linkedEnvironmentsEnabled: false, - }); - const offPatch =

(patch: P) => ({ - ...patch, - linkedEnvironmentsEnabled: false, - }); - const { updateSettingsWith } = settings; - return ServerSettings.ServerSettingsService.of({ - start: settings.start, - ready: settings.ready, - managedPolicy: settings.managedPolicy, - getSettings: Effect.map(settings.getSettings, off), - updateSettings: Effect.fn("LazurioBuddyGuards.updateSettings")(function* (patch) { - return off(yield* settings.updateSettings(offPatch(patch))); - }), - updateProviderInstance: Effect.fn("LazurioBuddyGuards.updateProviderInstance")( - function* (mutation, patch) { - return off(yield* settings.updateProviderInstance(mutation, offPatch(patch ?? {}))); - }, - ), - ...(updateSettingsWith === undefined - ? {} - : { - updateSettingsWith: Effect.fn("LazurioBuddyGuards.updateSettingsWith")( - function* (apply) { - return off(yield* updateSettingsWith((current) => off(apply(current)))); - }, - ), - }), - withSettingsSnapshot: Effect.fn("LazurioBuddyGuards.withSettingsSnapshot")(function* < - A, - E, - R, - >(use: (current: Settings) => Effect.Effect) { - return yield* settings.withSettingsSnapshot((current) => use(off(current))); - }), - // Upstream's are getters that subscribe on each read. - get streamChanges() { - return Stream.map(settings.streamChanges, off); - }, - get subscribeChanges() { - return Effect.map(settings.subscribeChanges, Stream.map(off)); - }, - }); - }), - ).pipe(Layer.provide(live)); diff --git a/apps/server/src/lazurio/inboundLinks.test.ts b/apps/server/src/lazurio/inboundLinks.test.ts new file mode 100644 index 0000000000000..545b133a934e7 --- /dev/null +++ b/apps/server/src/lazurio/inboundLinks.test.ts @@ -0,0 +1,275 @@ +// @effect-diagnostics nodeBuiltinImport:off - Each case writes its Machine's handover to a temporary folder. +import * as NodeFS from "node:fs"; +import * as NodeOS from "node:os"; +import * as NodePath from "node:path"; + +import { NodeHttpServer } from "@effect/platform-node"; +import * as NodeCrypto from "@effect/platform-node/NodeCrypto"; +import * as NodeServices from "@effect/platform-node/NodeServices"; +import { assert, describe, it } from "@effect/vitest"; +import { + EnvironmentHttpApi, + type ExecutionEnvironmentDescriptor, + OrchestratorMcpFailure, +} from "@t3tools/contracts"; +import * as HostProcess from "@t3tools/shared/HostProcess"; +import * as Context from "effect/Context"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import * as Schema from "effect/Schema"; +import { Tool, Toolkit } from "effect/ai"; +import * as HttpRouter from "effect/http/HttpRouter"; +import * as HttpServer from "effect/http/HttpServer"; +import * as HttpApi from "effect/http-api/HttpApi"; +import * as HttpApiBuilder from "effect/http-api/HttpApiBuilder"; + +import * as EnvironmentAuth from "../auth/EnvironmentAuth.ts"; +import * as AuthHttp from "../auth/http.ts"; +import * as McpOAuth from "../auth/McpOAuth.ts"; +import * as McpOAuthHttp from "../auth/mcpOAuthHttp.ts"; +import * as ServerSecretStore from "../auth/ServerSecretStore.ts"; +import * as CloudLink from "../cloud/CloudLink.ts"; +import * as ServerConfig from "../config.ts"; +import * as ServerEnvironment from "../environment/ServerEnvironment.ts"; +import * as ServerHttp from "../http.ts"; +import * as McpHttpServer from "../mcp/McpHttpServer.ts"; +import * as McpInvocationContext from "../mcp/McpInvocationContext.ts"; +import * as McpSessionRegistry from "../mcp/McpSessionRegistry.ts"; +import * as McpToolAccess from "../mcp/McpToolAccess.ts"; +import * as PeerLinks from "../peer/PeerLinks.ts"; +import { descriptorOf, layerLinkingEnvironment } from "../peer/PeerLinks.testkit.ts"; +import * as PeerMcpClient from "../peer/PeerMcpClient.ts"; +import * as Sqlite from "../persistence/Sqlite.ts"; +import * as ManagedPolicy from "../policy/ManagedPolicy.ts"; +import * as ServerSettings from "../serverSettings.ts"; +import { + INBOUND_LINKS_REFUSED, + refuseInboundLinkRegistration, + refuseLinkedClients, + refusesInboundLinks, +} from "./inboundLinks.ts"; + +/** A handover as Machines write it, reduced to what the guard reads. */ +const handover = (kind: string, zone?: string) => + JSON.stringify({ + schema_version: "lazurio.machine.v1", + machine: { id: `env-${kind}`, kind, name: "env", vmid: 101 }, + ...(zone === undefined ? {} : { relationships: { zone, peers: [] } }), + }); + +/** The path of a handover holding `content`, or of none when `content` is undefined. */ +const handoverAt = (content?: string) => { + const folder = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "lazurio-machine-")); + const path = NodePath.join(folder, "lazurio.machine.json"); + if (content !== undefined) NodeFS.writeFileSync(path, content); + return path; +}; + +describe("which machine refuses links into it", () => { + const cases: ReadonlyArray = [ + ["no handover: not a Lazurio Environment", undefined, false], + ["a Work Environment", handover("workspace-vm", "work"), false], + ["a Work Environment without relationships", handover("workspace-vm"), false], + ["a Personal Environment", handover("personal-vm", "personal"), true], + ["a Personal Environment without relationships", handover("personal-vm"), true], + ["a handover whose zone is personal", handover("workspace-vm", "personal"), true], + ["a kind the guard does not know", handover("conglomerate-host"), true], + ["a handover it cannot understand", "{ not json", true], + ["Buddy's T3 Code, also without a handover", undefined, true, { T3CODE_LAZURIO_BUDDY: "1" }], + ]; + it.effect.each(cases)("%s", ([, content, refuses, environment = {}]) => + Effect.gen(function* () { + assert.strictEqual(yield* refusesInboundLinks(handoverAt(content)), refuses); + }).pipe( + Effect.provide(NodeServices.layer), + Effect.provideService(HostProcess.Environment, environment), + ), + ); +}); + +const Probe = Schema.Struct({ caller: Schema.String }); +const ProbeToolkit = Toolkit.make( + Tool.make("probe", { + description: "Reports the calling client.", + success: Probe, + failure: OrchestratorMcpFailure, + failureMode: "return", + dependencies: [McpInvocationContext.McpInvocationContext], + }), +); +const probeTools = McpHttpServer.toolkitRegistration( + ProbeToolkit, + McpToolAccess.toLayer(ProbeToolkit, { + probe: McpToolAccess.reads(() => + Effect.map(McpInvocationContext.McpInvocationContext, (scope) => ({ + caller: scope.client?.label ?? "none", + })), + ), + }), +); + +class PeerTestApi extends HttpApi.make("environment") + .add(EnvironmentHttpApi.groups.metadata) + .add(EnvironmentHttpApi.groups.mcpOAuth) {} + +/** + * The environment a link points at, as `server.ts` builds its MCP OAuth and `/mcp`, on a machine + * whose handover is at `identityPath`. `guardRegistration: false` stands for a link registered + * before the guard was there. + */ +const serveTarget = ( + descriptor: ExecutionEnvironmentDescriptor, + identityPath: string, + { guardRegistration = true }: { readonly guardRegistration?: boolean } = {}, +) => + Effect.gen(function* () { + const authContext = yield* EnvironmentAuth.layer.pipe( + Layer.provide(ManagedPolicy.layerTest()), + Layer.provideMerge(ServerSettings.layerTest({ linkedEnvironmentsEnabled: true })), + Layer.provide(Sqlite.layerMemory), + Layer.provideMerge(ServerSecretStore.layer), + Layer.provideMerge(ServerEnvironment.layerIdentity), + Layer.provideMerge(ServerConfig.layerTest(process.cwd(), { prefix: "t3-inbound-links-" })), + Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)), + Layer.fresh, + Layer.build, + ); + const oauth = guardRegistration + ? refuseInboundLinkRegistration(McpOAuth.layer, identityPath) + : McpOAuth.layer; + const layerRoutes = Layer.mergeAll( + HttpApiBuilder.layer(PeerTestApi).pipe( + Layer.provide( + McpOAuthHttp.layer.pipe( + Layer.provide(oauth), + Layer.provide( + Layer.mock(CloudLink.CloudLink)({ + linkState: () => + Effect.succeed({ + linked: false, + cloudUserId: null, + relayUrl: null, + relayIssuer: null, + publishAgentActivity: false, + }), + }), + ), + ), + ), + Layer.provide(ServerHttp.layerServerEnvironmentHttpApi), + Layer.provide(AuthHttp.layerAuthenticatedAuth), + ), + McpHttpServer.layerMcpTransport(probeTools).pipe( + Layer.provide( + Layer.mock(McpSessionRegistry.McpSessionRegistry)({ resolve: () => Effect.undefined }), + ), + Layer.provide(refuseLinkedClients(McpOAuth.layerMcpClientAuthenticator, identityPath)), + ), + ).pipe( + Layer.provide( + Layer.succeed(ServerEnvironment.ServerEnvironment, { + getEnvironmentId: Effect.succeed(descriptor.environmentId), + getDescriptor: Effect.succeed(descriptor), + }), + ), + Layer.provide(Layer.succeedContext(authContext)), + ); + yield* HttpRouter.serve(layerRoutes, { disableListenLog: true, disableLogger: true }).pipe( + Layer.fresh, + Layer.build, + ); + const address = (yield* HttpServer.HttpServer).address; + if (address._tag === "UnixPathAddress") return yield* Effect.die("expected a TCP address"); + const auth = Context.get(authContext, EnvironmentAuth.EnvironmentAuth); + return { + url: `http://127.0.0.1:${address.port}`, + auth, + linkedSessions: Effect.map(auth.listSessions(), (sessions) => + sessions.filter((session) => session.client.label?.startsWith("T3 Code · ")), + ), + }; + }); + +const personal = descriptorOf("environment-personal", "Personal"); +const work = descriptorOf("environment-work", "Work"); + +/** The Environment that links. Links out read no handover, so its kind does not matter here. */ +const linkFrom = (descriptor: ExecutionEnvironmentDescriptor) => + layerLinkingEnvironment(descriptor).pipe( + Layer.build, + Effect.map((context) => ({ + links: Context.get(context, PeerLinks.PeerLinks), + peer: Context.get(context, PeerMcpClient.PeerMcpClient), + })), + ); + +const probe = ( + from: Effect.Success>, + to: ExecutionEnvironmentDescriptor, +) => + from.peer.call({ + environmentId: to.environmentId, + tool: "probe", + arguments: {}, + limits: { runtimeMode: "full-access", interactionMode: "default" }, + success: Probe, + }); + +describe("links between a Personal and a Work Environment", () => { + it.effect("a Personal Environment links out to a Work Environment, as upstream does", () => + Effect.scoped( + Effect.gen(function* () { + const target = yield* serveTarget(work, handoverAt(handover("workspace-vm", "work"))); + const from = yield* linkFrom(personal); + const pairing = yield* target.auth.issuePairingCredential(); + yield* from.links.link({ + url: target.url, + pairingCode: pairing.credential, + access: "auto", + }); + assert.deepStrictEqual(yield* probe(from, work), { caller: "T3 Code · Personal" }); + }), + ).pipe(Effect.provide(NodeHttpServer.layerTest)), + ); + + it.effect("nothing links into a Personal Environment", () => + Effect.scoped( + Effect.gen(function* () { + const target = yield* serveTarget( + personal, + handoverAt(handover("personal-vm", "personal")), + ); + const from = yield* linkFrom(work); + const pairing = yield* target.auth.issuePairingCredential(); + const refused = yield* from.links + .link({ url: target.url, pairingCode: pairing.credential, access: "auto" }) + .pipe(Effect.flip); + assert.strictEqual(refused.reason, "pairing_rejected"); + assert.include(refused.message, INBOUND_LINKS_REFUSED); + assert.deepStrictEqual(yield* target.linkedSessions, []); + }), + ).pipe(Effect.provide(NodeHttpServer.layerTest)), + ); + + it.effect("a Personal Environment's /mcp admits no linked client", () => + Effect.scoped( + Effect.gen(function* () { + const target = yield* serveTarget( + personal, + handoverAt(handover("personal-vm", "personal")), + { guardRegistration: false }, + ); + const from = yield* linkFrom(work); + const pairing = yield* target.auth.issuePairingCredential(); + yield* from.links.link({ + url: target.url, + pairingCode: pairing.credential, + access: "auto", + }); + // Linking again is then refused at registration, with the reason. + const refused = yield* probe(from, personal).pipe(Effect.flip); + assert.strictEqual(refused.code, "capability_denied"); + }), + ).pipe(Effect.provide(NodeHttpServer.layerTest)), + ); +}); diff --git a/apps/server/src/lazurio/inboundLinks.ts b/apps/server/src/lazurio/inboundLinks.ts new file mode 100644 index 0000000000000..332fec5c777b1 --- /dev/null +++ b/apps/server/src/lazurio/inboundLinks.ts @@ -0,0 +1,101 @@ +/** + * Lazurio overlay (decisions 0246 and 0091, Lazurio/LazurioPlatform): nothing links into a Personal + * Environment. Its T3 Code links out to its person's Work Environments as upstream does, but it + * refuses a peer link's registration and a linked client on `/mcp`. Machines name the Environment's + * kind in its handover; Buddy's T3 Code runs only on a Personal Environment. + */ +import { AuthMcpRegistrationError, MCP_PEER_LINK_SOFTWARE_ID } from "@t3tools/contracts"; +import * as HostProcess from "@t3tools/shared/HostProcess"; +import * as Effect from "effect/Effect"; +import * as FileSystem from "effect/FileSystem"; +import * as Layer from "effect/Layer"; +import * as Option from "effect/Option"; +import * as Schema from "effect/Schema"; + +import * as McpOAuth from "../auth/McpOAuth.ts"; +import * as McpHttpServer from "../mcp/McpHttpServer.ts"; +import { isBuddySurfaceEnvironment } from "./buddySurface.ts"; + +/** The handover Machines write into every hosted Environment, root-owned and world-readable. */ +const MACHINE_IDENTITY_PATH = "/etc/lazurio/lazurio.machine.json"; + +export const INBOUND_LINKS_REFUSED = + "That machine is a Personal Environment, and nothing links into one. Link from it instead."; + +const MachineIdentity = Schema.Struct({ + machine: Schema.Struct({ kind: Schema.String }), + relationships: Schema.optionalKey(Schema.Struct({ zone: Schema.optionalKey(Schema.String) })), +}); +const decodeMachineIdentity = Schema.decodeUnknownOption(Schema.fromJsonString(MachineIdentity)); + +/** + * Whether this machine refuses links into it: Buddy's T3 Code, or a handover that names a Personal + * Environment. Without a handover it is not Lazurio's, so upstream's; one it cannot read, or of a + * kind it does not know, refuses. + */ +export const refusesInboundLinks = Effect.fn("LazurioInboundLinks.refuses")(function* ( + identityPath: string, +) { + if (isBuddySurfaceEnvironment(yield* HostProcess.Environment)) return true; + const fs = yield* FileSystem.FileSystem; + const text = yield* fs.readFileString(identityPath).pipe( + Effect.asSome, + Effect.catch((error) => + Effect.succeed(error.reason._tag === "NotFound" ? Option.none() : Option.some("")), + ), + ); + if (Option.isNone(text)) return false; + const identity = Option.getOrUndefined(decodeMachineIdentity(text.value)); + const zone = identity?.relationships?.zone; + if (identity?.machine.kind === "workspace-vm" && zone !== "personal") return false; + if (identity?.machine.kind !== "personal-vm") { + yield* Effect.logWarning("Refusing links into this machine: its Lazurio handover is unclear.", { + identityPath, + }); + } + return true; +}); + +/** `live`, refusing a peer link's registration on a machine that refuses links into it. */ +export const refuseInboundLinkRegistration = ( + live: Layer.Layer, + identityPath: string = MACHINE_IDENTITY_PATH, +) => + Layer.effect( + McpOAuth.McpOAuth, + Effect.gen(function* () { + const oauth = yield* McpOAuth.McpOAuth; + if (!(yield* refusesInboundLinks(identityPath))) return oauth; + return McpOAuth.McpOAuth.of({ + ...oauth, + register: Effect.fn("LazurioInboundLinks.register")(function* (input) { + if (input.software_id !== MCP_PEER_LINK_SOFTWARE_ID) return yield* oauth.register(input); + return yield* new AuthMcpRegistrationError({ + error: "invalid_client_metadata", + error_description: INBOUND_LINKS_REFUSED, + }); + }), + }); + }), + ).pipe(Layer.provide(live)); + +/** `live`, admitting no linked client to `/mcp` on a machine that refuses links into it. */ +export const refuseLinkedClients = ( + live: Layer.Layer, + identityPath: string = MACHINE_IDENTITY_PATH, +) => + Layer.effect( + McpHttpServer.McpClientAuthenticator, + Effect.gen(function* () { + const authenticator = yield* McpHttpServer.McpClientAuthenticator; + if (!(yield* refusesInboundLinks(identityPath))) return authenticator; + return McpHttpServer.McpClientAuthenticator.of({ + authenticate: Effect.fn("LazurioInboundLinks.authenticate")(function* (request) { + const scope = yield* authenticator.authenticate(request); + if (scope?.client?.linked !== true) return scope; + yield* Effect.logWarning(INBOUND_LINKS_REFUSED, { client: scope.client.label }); + return undefined; + }), + }); + }), + ).pipe(Layer.provide(live)); diff --git a/apps/server/src/server.ts b/apps/server/src/server.ts index 663a0ba54a16f..860251d3428a6 100644 --- a/apps/server/src/server.ts +++ b/apps/server/src/server.ts @@ -47,6 +47,7 @@ import * as LazurioAgentBrowserSession from "./lazurio/agentBrowserSession.ts"; import * as LazurioAgentCliRequests from "./lazurio/agentCliRequests.ts"; import * as LazurioBuddyGuards from "./lazurio/buddySurfaceGuards.ts"; import * as LazurioBuddyPrompt from "./lazurio/buddyPrompt.ts"; +import * as LazurioInboundLinks from "./lazurio/inboundLinks.ts"; import * as ExternalLauncher from "./process/externalLauncher.ts"; import * as SpawnWorker from "./process/SpawnWorker.ts"; import * as NodePtyAdapter from "./terminal/NodePtyAdapter.ts"; @@ -278,8 +279,7 @@ const layerProviderEventLoggers = Layer.effect( const layerPtyAdapter = NodePtyAdapter.layer; -// Lazurio overlay (plan DEV-6676): no linked Environments in Buddy's T3 Code. -const layerServerSettings = LazurioBuddyGuards.withoutLinkedEnvironments(ServerSettings.layer).pipe( +const layerServerSettings = ServerSettings.layer.pipe( Layer.provide(ServerSecretStore.layer), Layer.provideMerge(ManagedPolicy.layer), Layer.provideMerge(SqlitePersistence.layerConfig), @@ -845,7 +845,12 @@ const layerMakeRoutes = Layer.mergeAll( Layer.mergeAll( HttpApiBuilder.layer(EnvironmentHttpApi).pipe( Layer.provide(AuthHttp.layer), - Layer.provide(McpOAuthHttp.layer.pipe(Layer.provide(McpOAuth.layer))), + // Lazurio overlay (decision 0246): nothing links into a Personal Environment. + Layer.provide( + McpOAuthHttp.layer.pipe( + Layer.provide(LazurioInboundLinks.refuseInboundLinkRegistration(McpOAuth.layer)), + ), + ), Layer.provide(CloudHttp.layer), Layer.provide(OrchestrationHttp.layer), Layer.provide(PullRequestHttp.layer), @@ -870,7 +875,9 @@ const layerMakeRoutes = Layer.mergeAll( Layer.provide(ProviderAdapterRegistry.layerFromProviderInstanceRegistry), // Lazurio overlay (plan DEV-6676): an agent command's idempotency key holds across commands. Layer.provide( - LazurioAgentCliRequests.withAgentCliRequestNamespace(McpOAuth.layerMcpClientAuthenticator), + LazurioAgentCliRequests.withAgentCliRequestNamespace( + LazurioInboundLinks.refuseLinkedClients(McpOAuth.layerMcpClientAuthenticator), + ), ), ), // Follows delegated tasks running in linked environments, including after a restart. diff --git a/docs/operations/lazurio-fork-release.md b/docs/operations/lazurio-fork-release.md index 0f60cff9118f1..be51ed0420e0f 100644 --- a/docs/operations/lazurio-fork-release.md +++ b/docs/operations/lazurio-fork-release.md @@ -160,7 +160,7 @@ Lazurio/t3code#112, na v0.1.1 Lazurio/t3code#97, na v0.1.0 Lazurio/t3code#70). | 22 | `feat(server): T3's Codex threads ask the user through request_user_input` | Rozhodnutí 0211: agent se člověka ptá nástrojem na otázky, ne jen textem ve zprávě. Codex nabízí `request_user_input` v režimu Default jen se zapnutou funkcí `default_mode_request_user_input`; T3 ji zapne app-serveru, který pro svá vlákna spouští, a do kontextu každého tahu dá pokyn ptát se jím, i když bez odpovědi nejde pokračovat (viz [Nástroj na otázky](#nástroj-na-otázky)). Uživatelův `~/.codex/config.toml` se nemění (rozhodnutí 0161). | Upstream ekvivalent nemá a funkci sám nezapíná. Je to politika Lazuria nad funkcí Codexu ve vývoji (ve výchozím stavu vypnutá): pokyn Lazuria zůstává v overlayi a upstreamu se v etapě 9 nabídne jen mechanismus. Šev je přepínač `-c` v `CodexAdapterV2.ts` před argumenty spuštění a položka `lazurio_questions` na konci `buildCodexAdditionalContext`, pod limitem 4 000 bajtů; testy řádku jsou v `lazurio/questionTool.test.ts`. Na v0.1.3 T3 texty režimů neposílá (#24737) a Codex posílá svůj text Default, proto šev věty v textu Default odpadl a `lazurio_questions` výslovně říká, že přebíjí, co režim říká o ptaní; že se Codex ptá nástrojem, ověřte na canary tahem s Codexem. Na v0.1.4 upstream měří kontext agenta proti `agentContextBudget.json` (#25785); fork CI ten test nespouští (overlay jeho soubory nemění), proto rozpočet zůstává upstreamu a nárůst o `lazurio_questions` zapisuje issue přestavby. App-server obnovený po pádu (#26188) dostane přepínač stejně. Při přestavbě ověřte v `codex features list`, že Codex funkci pořád zná; jakmile ji zapne ve výchozím stavu sám, přepínač odeberte, pokyn zůstává. Na v0.1.5 beze změny. Na v0.1.6 beze změny. Na v0.1.7 potřebuje továrna klienta app-serveru `PortDiscovery` a argumenty spouštěného příkazu jsou `Words`: test přepnutí dává `PortScanner.layerTest` a argumenty čte jako řetězce a test otázky v režimu Default dává `NodeCrypto` pro `Digest` adaptéru. `codex features list` v Codexu 0.166.0 (archiv linux-x64 z `CodexInstallation.ts` se shodným sha256 i Codex CLI na Prostředí) uvádí `default_mode_request_user_input` jako „under development“ a vypnutou, s přepínačem `-c` zapnutou. Na v0.1.8 vede upstream tajné údaje přes `request_secret` (#30257), kdežto `lazurio_questions` o nich mlčel, takže by model mohl heslo žádat otázkou a odpověď by zůstala ve vlákně. `lazurio_questions` proto říká, že heslo, token, PIN ani párovací kód se tímto nástrojem nežádá, ale přes `request_secret` T3 Code (rozhodnutí A6 v Lazurio/t3code#185), a test v `lazurio/questionTool.test.ts` to hlídá. Upstream odebral přepínač plánovacího režimu (#33131), takže běžné tahy Codexu z UI běží v režimu Default. Rozpočet kontextu: `codexAdditionalContextBytes` je 8790 bajtů proti 7279 v souboru upstreamu a `mcpToolListJsonBytes` 48415 proti 48233; overlay `agentContextBudget.json` nemění. Na v0.1.9 se řádek přehrál beze změny; `CodexAdapterV2.ts` upstreamu mění zobrazení obrázků a limity použití (#30473, #27791). Rozpočet kontextu je na v0.1.9 `codexAdditionalContextBytes` 8838 bajtů proti 7327 v souboru upstreamu, `mcpToolListJsonBytes` 48399 proti 48217 a `claudeSystemAppendBytes` 5597 jako v upstreamu; `AgentContextBudget.test.ts` upstreamu proto mimo Fork CI, který ho nespouští, selže. Codex zůstává `0.166.0` (`CodexInstallation.ts` beze změny) a `codex features list` z jeho archivu linux-x64 dál uvádí `default_mode_request_user_input` jako „under development“, vypnuté a s `-c features.default_mode_request_user_input=true` zapnuté (ověřeno 2026-11-13). | | 23 | `feat(lazurio): Buddy's Hermes gets only the person's words and the page as a Czech block` | Rozhodnutí 0210 (plán DEV-6676): Buddyho chat drží na Osobním Prostředí druhý server T3 s `T3CODE_LAZURIO_BUDDY=1`, jehož instance poskytovatele `buddy` pouští Hermes Agenta (`hermes acp`). Hermes ukládá každý prompt do Buddyho paměti jako slova člověka, proto mu T3 posílá jen text člověka, jeho přílohy a stránku, ze které se ptá, jako jeden označený český blok, nikdy své pokyny (``, ``, ``), ani po Stop, při usměrnění a po restartu. Od dodatku HumanAndMachines/Lazurio#648 jí T3 nenastaví model, úsilí ani jinou volbu než rychlost Hermesu (`fast`): model a úsilí nastavuje Platforma v Hermesově nastavení ([Buddyho T3 Code](#buddyho-t3-code)). | Upstream ekvivalent nemá: zůstává. Adaptér ACP (`packages/provider-acp/src/server/adapter.ts`) se při stavbě instance ptá `AcpT3Instructions` (bez odpovědi dostane pokyny každá instance), `server.ts` odpoví pro Buddyho instanci tam, kde staví instance poskytovatelů, a `orchestration-v2/ProviderTurnStartService.ts` promítne pro ni kontext stránky jako blok místo obecného ``. Výběr modelu a voleb hlídá druhý přepínač, `AcpT3Selection`, na jediném místě, kde ho adaptér nastavuje (`configureSession`); `server.ts` odpovídá oběma přepínačům jedním obalem `withBuddyInstance` a test přepínače stojí vedle testů adaptéru v `AcpAdapterV2.test.ts`. Na v0.1.3 upstream počítá slash příkaz z textu, který přepíše flavor (`rewriteUserText`, #24605); přestavba vzala tento řádek a ponechala bránu pokynů. Oznámení ACP jsou nově položky `system_notice` (#25704) a Buddyho časová osa je neukazuje. Na v0.1.4 upstream přesunul sestavení textu tahu (#25610, #25660), takže šev v `ProviderTurnStartService.ts` stojí na novém místě, a `server.ts` za Buddyho obal instancí skládá `layerPortScanner` (#26245). Nová cesta `forceNewNativeThread` (#25610) vynuluje výběr, takže další tah projde zase přes `configureSession`; usměrnění ACP během kompakce čeká ve frontě (#25837) a pak jde jako nový tah stejnou cestou. Obecné přepínače pokynů a výběru T3 pro instanci ACP lze nabídnout upstreamu. Při přestavbě ověřte, že adaptér ACP skládá prompt dál na jediném místě (`resolvePromptParts`), výběr nastavuje dál jen `configureSession` při startu, načtení a změně výběru a že usměrnění tahu ACP je dál přerušení a nový tah přes `ProviderTurnStartService`, kromě agenta, který usměrnění za běhu umí: ten od řádku 33 dostane přes `_lazurio/steer` text zprávy a stránku jako český blok (Lazurio/t3code#150, od v0.1.7). Na v0.1.5 je v `adapter.ts` `writeTextFile` klienta souborového systému volitelné (#26876), mimo bloky overlaye. Na v0.1.6 ověřuje adaptér ACP model tahu proti modelům sezení před začátkem tahu (#26623). Kde volby jmenuje `AcpT3Selection`, nastavuje model agenta hostitel a T3 žádný nepoužije, proto `validateModelSelection` tuto kontrolu přeskočí, jako u varianty, která výběr aplikuje sama: model, který sezení už nenabízí, by jinak odmítl každý tah Buddyho. Test adaptéru V2 takový model pošle a tah proběhne. Na v0.1.7 filtruje ACP adaptér volby T3 přes vlastní volby flavoru a strop režimu v jednom `flatMap`; brána `AcpT3Selection` je v něm další časný návrat, po vlastních volbách flavoru a před stropem. Poznámky runtime, které upstream nově skládá z aktivního nastavení sezení, zůstávají za `sendsT3Instructions`. Adaptér importuje `Context` vedle `SecureRandom` upstreamu a testy Buddyho dávají `NodeCrypto` vedle `NodeServices`. Na v0.1.8 jsou švy beze změny. #30361 dává agentům ACP, tedy i Hermesovi, `T3CODE_THREAD_ID` a #30377 přidává hlídání nečinnosti promptu jen pro Antigravity; ani jedno část řádku nenahrazuje. Na v0.1.9 se řádek přehrál beze změny; `ProviderTurnStartService.ts` upstreamu čte méně historie vlákna (#25728) a zrcadlí nativní cíle OpenCode (#33758). | | 24 | `feat(lazurio): agents send once per idempotency key, and Delegace finds Buddy's thread` | Rozhodnutí 0210 (plán DEV-6676): Delegace budí Buddyho zprávou do jeho vlákna (`t3 thread send … --mode queue`) a po pádu ji pošle znovu. `--idempotency-key` ji pošle jednou na klíč, vlákno a odesílatele i napříč příkazy a restarty a `t3 lazurio buddy thread --json` řekne, které vlákno je Buddyho, a napoprvé ho založí (viz [Agenti a vlákna](#agenti-a-vlákna) a [Buddyho T3 Code](#buddyho-t3-code)). Probuzení od Delegace se ve vlákně neukáže, uživatel vidí jen Buddyho odpověď; zařídí to stopa „Buddy za …“ (řádek 27), ne tento řádek. | Upstream ekvivalent nemá: zůstává. Klíč je upstream `clientRequestId` nástroje `t3_thread_send`, jenže ten platí v jmenném prostoru klienta MCP, tedy jeho sezení, a každý agentní příkaz má sezení vlastní. Šev je dekorátor `McpClientAuthenticator` v `server.ts`: sezení agentních příkazů (štítek `t3 agent cli`) sdílejí jeden prostor, příkaz předá otisk klíče s vláknem a odesílatelem, potvrzenky příkazů T3 ho provedou jednou a cesta overlaye `send-state` řekne, co z odeslání zbylo. Ostatní klienti MCP mají prostor upstreamu. Buddyho vlákno najde nebo založí cesta overlaye `POST /api/lazurio/buddy/thread`. Klíč se vyhodnotí před odesláním a `--wait` čeká jen na běh tohoto odeslání nebo přehrané potvrzenky; odmítnutí, střet ani opakování, které odpoví „delivered“, nečekají. Opakování čeká podle toho, zda bylo vlákno nečinné při odeslání, které T3 přijal: posílá jen držitel nároku na klíč a souběžné odeslání téhož klíče skončí `send_in_progress` (`followWakes`, `CLAIM_TTL_MS`, rozsah `orchestration:operate`). Na v0.1.3 je `stableCommandId` beze změny, nové pole `link` výsledku `t3_thread_send` (#24784) schéma ignoruje a dekorátor `authenticate` je `Effect.fn` jako upstreamový `McpOAuth` (#25099). Na v0.1.4 přijímá `clientRequestId` i `t3_thread_launch` (#16654), ale v témže jmenném prostoru sezení, takže ekvivalentem není. Od #26642 dává upstream vnějším klientům MCP odkaz na webovou aplikaci z původu požadavku; agentní příkazy jdou přes loopback, proto dekorátor jejich sezením (štítek `t3 agent cli`) `webOrigin` odebere a odkazy zůstávají `t3-thread://`. Při přestavbě ověřte, že upstream dál odvozuje id příkazu z `requestNamespace` a klíče a že potvrzenka příkazu přehraje jeho události. Na v0.1.5 beze změny. Na v0.1.6 nesou projekty upstreamu `pinnedAt` a `archivedAt` (#26154), takže projekt v testu Buddyho vlákna je má `null`. Na v0.1.7 hashuje klíč odeslání přes `effect/crypto/Digest` (sha256) a testkit Buddyho povrchu dává `NodeCrypto`. Upstream přejmenoval `webOrigin` klienta MCP na `hostedAppUrl`, takže rozsah agentních příkazů odebírá `hostedAppUrl` a jejich odkazy na vlákna zůstávají `t3-thread://`; každý jiný klient MCP si nechá odkaz na hostovanou aplikaci, který nastaví `McpOAuth`. Na v0.1.8 skládá upstream stabilní id příkazu a zprávy `thread_send` dál stejně, s operací `thread-send`, takže kontrakt řádku platí. `thread_send` MCP nově bere `freshContext` (#30323), který agentní příkazy neposílají, a `threadLinkFor` bere nepovinný název (#33255, řádek 21). Na v0.1.9 beze změny. | -| 25 | `feat(lazurio): Buddy's T3 Code is Buddy's one conversation, framed by the bubble` | Rozhodnutí 0210 (plán DEV-6676): Buddyho T3 Code je jediný rozhovor. Web místo aplikace T3 ukáže Buddyho povrch: hlavičku s Mattyčusem, dny rozhovoru a čáru nad prvním dnem, bez seznamu vláken, nového vlákna, větvení a návratu; další zpráva tah usměrní, frontu člověk volí výslovně. V bublině mluví s hostitelem protokolem `lazurio.buddy.*` v1 a nosí vzhled jeho stránky. Server totéž drží pro každého klienta a v Buddyho projektu nedělá checkpointy (viz [Buddyho T3 Code](#buddyho-t3-code)). | Upstream ekvivalent nemá: zůstává. Kód je v `apps/*/src/lazurio/` (`buddySurface*`, `BuddySurface.tsx`). Švy jsou dekorátory tam, kde se služby skládají (stráž příkazů v `orchestration-v2/runtimeLayer.ts`, `CheckpointStore` a `ServerSettingsService` v `server.ts`), fáze startu v `serverRuntimeStartup.ts` před obnovou, klíč `lazurioBuddy` v konfiguraci klienta (`ws.ts`, `packages/contracts/src/server.ts`) a ve webu `routes/__root.tsx` (povrch místo sidebaru a palety), `routes/_chat.index.tsx` (`/` otevře Buddyho vlákno), `routes/_chat.tsx`, `ChatView.tsx` a `MessagesTimeline.tsx` (dny a skok na den). Pole `buddySurface` je ve sdíleném stavu řádků (`chat/timelineRowContext.ts`) a tlačítko větvení skrývá `chat/TimelineAssistantRows.tsx`. Na v0.1.3 upstream instaluje zkratky trasy chatu jednou při startu aplikace (#25366), proto Buddyho podmínka stojí v jejich `when` (`shortcuts/chatRouteCommands.ts`, `isBuddySurfaceNow`), a skok na den bere `navigateTimeline` časové osy (#25463). Sdílení vlákna s hostem (#24104) stráž příkazů odmítá (`thread.guest-share.open`, `.redeem` a `thread.guest-message.submit`) a root na Buddyho povrchu nekreslí `GuestShareDialogHost`, protože Personalspace se nesdílí (rozhodnutí 0091). Nastavení a Využití jsou modální okna nad vláknem (#24847); jestli na ně Buddyho povrch dosáhne, ověřte na canary. Na v0.1.4 ukazuje upstream čekající schválení na jeho řádku práce (#26255) a jen schválení bez řádku v patičce časové osy; na Buddyho povrchu, kde řádky práce nejsou, tam padnou všechna a `listExtraData` nese `buddyDays` vedle patičky. Root drží `localEnvironmentDisabled` (#26207) vedle `buddySurface`, typ panelu detailu se bere z `ComponentProps` (#26238 zrušil export) a nová vzdálená delegace (#26434) a žádost o propojení Environmentu (#17129) jsou položky, ne příkazy větvení, návratu nebo sdílení. Propojené Environmenty (#16655, #16684, #17129) by k Buddyho vláknu pustily jiné Environment přes MCP mimo stráž příkazů, proto je Buddyho T3 Code vypíná: `withoutLinkedEnvironments` čte `linkedEnvironmentsEnabled` vždy vypnuté, i když ho nastavení zapíná, a všechny brány upstreamu (OAuth propojení, `/mcp` propojeného klienta, odchozí propojení, žádosti o propojení, vzdálené úkoly) ho čtou z `getSettings`. Každý zápis nastavení ho navíc uloží vypnuté, i výchozí nastavení Buddyho při prvním startu, a `t3 environment link`, který si nastavení staví sám (`cli/environment.ts`), je obalené stejnou strážou; propojení tak nezaloží ani příkaz spuštěný bez `T3CODE_LAZURIO_BUDDY`. Při přestavbě ověřte, že usměrnění dál volí `followUpBehavior`, že `throughEntryId` historie dál přijímá id zprávy, že upstream nepřidal další cestu k větvení, návratu nebo sdílení mimo příkazy orchestrace a že žádná cesta propojení Environmentů nečte `linkedEnvironmentsEnabled` jinudy než ze `ServerSettingsService` obaleného `withoutLinkedEnvironments` (`server.ts`, `cli/environment.ts`). Na v0.1.5 se bloky overlaye v `runtimeLayer.ts`, `ws.ts`, `ChatView.tsx` a `server.ts` nepotkaly se změnami upstreamu (#26767, #26904, #26859, #26288). Na v0.1.6 vykreslí postranní chat (#26901) `ChatView` vložený, bez hlavičky, hostitele obnovy větve a detailů vlákna; Buddyho skrytá hlavička a `BuddyThreadDetailsPanel` jsou uvnitř nových větví upstreamu. Buddyho jediný rozhovor postranní chat nenabízí: `sideChatsOffered` je na Buddyho povrchu `false`, takže ho nenabídne panel ani nabídka lomítka, a napsané `/side` nebo `/btw` dostane důvod „Buddy's conversation has no side chats.“, místo aby došlo Buddymu jako text (server by jeho `thread.fork` stejně odmítl). Denní čáry časové osy stojí před novou sadou spárovaných žádostí o schválení (#27420). Na v0.1.7 dává upstream vrstvě nastavení CLI spravovanou politiku (`ManagedPolicy.layer`). CLI drží Buddyho stráž kolem `ServerSettings.layer` a dává `ManagedPolicy.layer` vedle úložiště tajemství a perzistence. Test startu dává `ManagedPolicy.layerTest()` a `NodeCrypto.layer`. Na v0.1.8 přidal upstream čerstvé sezení poskytovatele z `/clear`, z `thread_send` MCP a z plánované úlohy (#30323, #30325, #30326) a dialog „Use in another app“ (#33196). Vlákno Buddyho odmítne `message.dispatch` s `freshContext` a `ChatView.tsx` tam `/clear` nenabídne (rozhodnutí A7 v Lazurio/t3code#185); odmítnutí je v `buddySurfaceGuards.ts` a hlídá ho test. Plocha Buddyho nemá hostitele dialogu „Use in another app“, stejně jako vynechává hostitele sdílení pro hosty (rozhodnutí A8). `__root.tsx` následuje rozdělení uvítání upstreamu (#33209) a `FirstRunGate` zůstává na ploše Buddyho vypnutý. Na v0.1.9 se řádek přehrál beze změny. Stránka `/approve-agent` (#33600) se vykresluje mimo aplikaci jako `/pair` a `/connect`, takže ji plocha Buddyho neobaluje. | +| 25 | `feat(lazurio): Buddy's T3 Code is Buddy's one conversation, framed by the bubble` | Rozhodnutí 0210 (plán DEV-6676): Buddyho T3 Code je jediný rozhovor. Web místo aplikace T3 ukáže Buddyho povrch: hlavičku s Mattyčusem, dny rozhovoru a čáru nad prvním dnem, bez seznamu vláken, nového vlákna, větvení a návratu; další zpráva tah usměrní, frontu člověk volí výslovně. V bublině mluví s hostitelem protokolem `lazurio.buddy.*` v1 a nosí vzhled jeho stránky. Server totéž drží pro každého klienta a v Buddyho projektu nedělá checkpointy (viz [Buddyho T3 Code](#buddyho-t3-code)). | Upstream ekvivalent nemá: zůstává. Kód je v `apps/*/src/lazurio/` (`buddySurface*`, `BuddySurface.tsx`). Švy jsou dekorátory tam, kde se služby skládají (stráž příkazů v `orchestration-v2/runtimeLayer.ts`, `CheckpointStore` a `ServerSettingsService` v `server.ts`), fáze startu v `serverRuntimeStartup.ts` před obnovou, klíč `lazurioBuddy` v konfiguraci klienta (`ws.ts`, `packages/contracts/src/server.ts`) a ve webu `routes/__root.tsx` (povrch místo sidebaru a palety), `routes/_chat.index.tsx` (`/` otevře Buddyho vlákno), `routes/_chat.tsx`, `ChatView.tsx` a `MessagesTimeline.tsx` (dny a skok na den). Pole `buddySurface` je ve sdíleném stavu řádků (`chat/timelineRowContext.ts`) a tlačítko větvení skrývá `chat/TimelineAssistantRows.tsx`. Na v0.1.3 upstream instaluje zkratky trasy chatu jednou při startu aplikace (#25366), proto Buddyho podmínka stojí v jejich `when` (`shortcuts/chatRouteCommands.ts`, `isBuddySurfaceNow`), a skok na den bere `navigateTimeline` časové osy (#25463). Sdílení vlákna s hostem (#24104) stráž příkazů odmítá (`thread.guest-share.open`, `.redeem` a `thread.guest-message.submit`) a root na Buddyho povrchu nekreslí `GuestShareDialogHost`, protože Personalspace se nesdílí (rozhodnutí 0091). Nastavení a Využití jsou modální okna nad vláknem (#24847); jestli na ně Buddyho povrch dosáhne, ověřte na canary. Na v0.1.4 ukazuje upstream čekající schválení na jeho řádku práce (#26255) a jen schválení bez řádku v patičce časové osy; na Buddyho povrchu, kde řádky práce nejsou, tam padnou všechna a `listExtraData` nese `buddyDays` vedle patičky. Root drží `localEnvironmentDisabled` (#26207) vedle `buddySurface`, typ panelu detailu se bere z `ComponentProps` (#26238 zrušil export) a nová vzdálená delegace (#26434) a žádost o propojení Environmentu (#17129) jsou položky, ne příkazy větvení, návratu nebo sdílení. Propojené Environmenty (#16655, #16684, #17129) by k Buddyho vláknu pustily jiné Environment přes MCP mimo stráž příkazů, proto do Buddyho T3 Code žádné propojení nevede; ven propojuje jako každý T3 Code Osobního Prostředí (řádek 38). Při přestavbě ověřte, že usměrnění dál volí `followUpBehavior`, že `throughEntryId` historie dál přijímá id zprávy, že upstream nepřidal další cestu k větvení, návratu nebo sdílení mimo příkazy orchestrace a že do Buddyho T3 Code nevede žádná cesta propojení mimo stráže řádku 38. Na v0.1.5 se bloky overlaye v `runtimeLayer.ts`, `ws.ts`, `ChatView.tsx` a `server.ts` nepotkaly se změnami upstreamu (#26767, #26904, #26859, #26288). Na v0.1.6 vykreslí postranní chat (#26901) `ChatView` vložený, bez hlavičky, hostitele obnovy větve a detailů vlákna; Buddyho skrytá hlavička a `BuddyThreadDetailsPanel` jsou uvnitř nových větví upstreamu. Buddyho jediný rozhovor postranní chat nenabízí: `sideChatsOffered` je na Buddyho povrchu `false`, takže ho nenabídne panel ani nabídka lomítka, a napsané `/side` nebo `/btw` dostane důvod „Buddy's conversation has no side chats.“, místo aby došlo Buddymu jako text (server by jeho `thread.fork` stejně odmítl). Denní čáry časové osy stojí před novou sadou spárovaných žádostí o schválení (#27420). Na v0.1.7 dává upstream vrstvě nastavení CLI spravovanou politiku (`ManagedPolicy.layer`). CLI dává `ManagedPolicy.layer` vedle úložiště tajemství a perzistence. Test startu dává `ManagedPolicy.layerTest()` a `NodeCrypto.layer`. Na v0.1.8 přidal upstream čerstvé sezení poskytovatele z `/clear`, z `thread_send` MCP a z plánované úlohy (#30323, #30325, #30326) a dialog „Use in another app“ (#33196). Vlákno Buddyho odmítne `message.dispatch` s `freshContext` a `ChatView.tsx` tam `/clear` nenabídne (rozhodnutí A7 v Lazurio/t3code#185); odmítnutí je v `buddySurfaceGuards.ts` a hlídá ho test. Plocha Buddyho nemá hostitele dialogu „Use in another app“, stejně jako vynechává hostitele sdílení pro hosty (rozhodnutí A8). `__root.tsx` následuje rozdělení uvítání upstreamu (#33209) a `FirstRunGate` zůstává na ploše Buddyho vypnutý. Na v0.1.9 se řádek přehrál beze změny. Stránka `/approve-agent` (#33600) se vykresluje mimo aplikaci jako `/pair` a `/connect`, takže ji plocha Buddyho neobaluje. | | 26 | `feat(lazurio): the page Buddy is asked from travels as a chip the person can remove` | Rozhodnutí 0210 (plán DEV-6676): Buddyho povrch ukáže nad composerem poslední platný kontext stránky hostitele jako čip, který člověk může odebrat. Dokud tam je, nese zpráva, kterou člověk napíše, stránku jako záznam `lazurio-page` s odkazem v textu a Hermes ji dostane jako český blok řádku 23. Odeslaná zpráva ukáže stejný čip (viz [Buddyho T3 Code](#buddyho-t3-code)). | Upstream ekvivalent nemá: zůstává. Kód je v `apps/web/src/lazurio/` (`buddySurfacePage.ts`, `BuddySurfacePageChip.tsx`). Záznam je obecný `UnknownContextRecord` kontraktů, takže se kontrakt nemění. Odeslání je v `chat/useComposerSend.ts`: odkaz v textu a záznam přibývají tam, záznam stránky dostane háček od ChatView jako vstup (odebrání čipu žije ve stavu jediného `useBuddyPage`) a snímek pro obnovu po neúspěšném odeslání stránku nedrží. Záložní čip odeslané zprávy je v registru `chat/UserMessageContextChips.tsx`, v composeru v `composerContextPresentation.tsx`. Na v0.1.3 se řádek přenesl beze změny; odeslání zpětné vazby ke schválení (#23657) posílá jen slova člověka bez stránky. Na v0.1.4 upstream přidal kontext propojených Environmentů (#17130): záznam stránky obaluje kontext zprávy i s jejich `environmentContexts`. Při přestavbě ověřte, že `messageTextForSend` dál drží jen slova člověka, která neúspěšné odeslání vrací do composeru, a že neznámé druhy dál končí v záložním vykreslení registrů. Na v0.1.5 viz řádek 9. Na v0.1.6 dostane vložený text, hlasová poznámka i soubor vlastní čip (#27377) a upstream importuje `userMessageFileLabel` vedle `buddyPageReferenceChip`. Slova, která člověk napsal, putují dál odděleně od stránky: nové cesty `useComposerSend` pro postranní chat a hvězdu na `pageTextForSend` nesahají a Buddyho povrch postranní chat nenabízí. Na v0.1.7 beze změny. Na v0.1.8 upstream odebral plánovací režim (#33131) a do `useComposerSend.ts` přidal odeslání s čerstvým sezením (#30325); overlay bere strukturu upstreamu a dál posílá `messageText: pageTextForSend`. `BuddyPageChip` stojí v `ChatView.tsx` dál vedle čipů kontextu composeru. Koncept jen s čipem stránky by mohl nabídnout `/clear`, na ploše Buddyho ale `/clear` není a stráž čerstvé sezení odmítne (řádek 25). Na v0.1.9 se řádek přehrál beze změny; odeslání během nahrávání příloh (#33092) posílá dál `messageText: pageTextForSend`. | | 27 | `feat(lazurio): a thread shows when Buddy or Delegace sent a message or decided a request` | Rozhodnutí 0210, večerní dodatek, bod 5 (úkol task-2026-10-20-330): co Buddy napíše nebo schválí ve vlákně, nese viditelnou značku „Buddy za “, a probuzení od Delegace v Buddyho vlastním vlákně se neukáže (rozhodnuto 2026-10-22). Agentní příkaz, jehož prostředí jmenuje, za koho jedná (`T3CODE_ACTING_SENDER`), vydá sezení s podepsaným tvrzením; server podle něj zapíše zprávy a rozhodnutí žádostí, které sezení poslalo, a web je ve vlákně označí, nebo probuzení skryje (viz [Kdo jednal: Buddy a Delegace](#kdo-jednal-buddy-a-delegace)). | Upstream ekvivalent nemá: zprávu od agenta zvenku vlákna složí do řádku se jménem vlákna odesílatele, jinak „Agent“ (#23135), a u rozhodnutí žádosti autora nezná. Jde o pojem Lazuria (Buddy jednající za člověka), proto zůstává v overlayi; upstreamu by šlo nabídnout jen obecné tvrzení sezení. Šev: tvrzení `act` vedle `rtc` v `SessionStore.ts`, `actingSender` v `EnvironmentAuth.ts` (vydání a ověřené sezení), přenos do vyvolání klienta MCP (`McpOAuth.ts`, `McpInvocationContext.ts`), jedno volání v `ws.ts`, jedno obalení orchestrátoru v `runtimeLayer.ts` a ve webu řádky vlákna v `MessagesTimeline.tsx`, popisek složené zprávy agenta v `chat/TimelineUserMessageRow.tsx` a značka u rozhodnuté žádosti v `chat/TimelineWorkEntryRow.tsx`. Záznam leží v souborech v T3 home, databáze zůstává upstreamu. Na v0.1.3 upstream počítá štítek složené zprávy jednou jako `senderLabel` (#24104), který čte i nadpis pro čtečky (#23780); overlay obaluje jen viditelný štítek. `McpOAuth.authenticate` je `Effect.fn` (#25099) a klient v něm dostane jeden řádek s `actingSender`. Atribuce hosta upstreamu (#24104) je záznam kontextu zprávy a nevyznačuje, kdo za koho jednal. Na v0.1.4 upstream přidal do tvrzení sezení klíč propojení Environmentů `plk` (#16695); `act` stojí vedle něj jako vedle `rtc` a `actingSender` stojí v `EnvironmentAuth.ts`, `McpOAuth.ts` a `McpInvocationContext.ts` vedle `peerLink`, `narrowedTo` a `webOrigin` (#16653, #26642). Fronta nově ukazuje odesílatele zprávy (#26159), ale bez „Buddy za …“, které zůstává časové ose. Při přestavbě ověřte, že upstream nezměnil tvar tvrzení tokenu sezení ani to, že dispatch klienta MCP a plochy uživatele běží ve vlákně požadavku, a že zprávu agenta dál nese řádek druhu `message`. Na v0.1.5 beze změny bloků overlaye. Na v0.1.6 beze změny. Na v0.1.7 přejmenoval upstream `webOrigin` volajícího MCP na `hostedAppUrl` a nastavuje ho v autentizátoru OAuth každému klientovi, který není peer link; jednající odesílatel jede vedle něj beze změny. Testy auth dávají `ManagedPolicy.layerTest()` a `NodeCrypto.layer`. Na v0.1.8 podepisuje upstream token sezení přes `PayloadSigner` (#30501, #30523); tvrzení `act` vedle `rtc` a `plk` se nezměnilo, protože se změnil podpis, ne schéma tvrzení. Časová osa nově nese viditelnost volání nástrojů (#30000) vedle značky jednajícího odesílatele. Na v0.1.9 se řádek přehrál beze změny; upstream odebral `authenticateBrowserSession` a schvaluje přes `approvingSession` (#33632), tvrzení `act` a značka jednajícího odesílatele se nezměnily. | | 28 | `feat(lazurio): Buddy's chat reads like a chat with a friend` | Rozhodnutí 0210, dodatek z 2026-10-22, bod 1, a dodatek HumanAndMachines/Lazurio#648: Buddyho chat ukazuje jen to, co Buddy napíše, a dokud Buddy pracuje, i na práci, která běží po tahu, jeden tichý řádek „Buddy na tom pracuje…“. Práci T3 (nástroje, příkazy, uvažování, „Worked for“, úkoly tahu, práci na pozadí) neukazuje, chybu řekne lidskými slovy. Composer nenabízí model, úsilí uvažování, přístup ani režim, jen přepínač Normální / Rychlý, když ho Hermes nabízí, a vlákno běží vždy ve full-access. Pole zprávy říká „Napište Buddymu…“ a fronta drží jen zprávy člověka. Klávesy terminálu, pravého panelu a voleb, které composer nenabízí, nechá prohlížeči (#109). Terminál ani pravý panel T3 neukáže, ať vlákno drží cokoli, a odkaz v rozhovoru otevře v nové záložce prohlížeče. Viz [Buddyho T3 Code](#buddyho-t3-code). | Upstream ekvivalent nemá: zůstává. Kód je v `apps/web/src/lazurio/` (`buddySurfaceTimeline.ts`, `buddySurfaceControls.ts`, `BuddySurface.tsx`). Švy: `MessagesTimeline.tsx` (řádky, které nechá řádek 27, projdou `buddySurfaceRows`, řádek nejdřív zkusí `buddyRowContent`, prop `buddyBackgroundWork`, řádky bez `onRunShellCommand`), `ChatComposer.tsx` (zástupný text z `useBuddyComposer`), `ComposerControlsBar.tsx` (`BuddyComposerControls` místo všech ovládacích prvků T3), `ChatBannerLane.tsx` (`BuddyThreadErrorBanner`), `ChatView.tsx` (`useBuddyChatShortcuts`, režim běhu přes `buddyRuntimeMode`, položky práce na konci časové osy maskované v těle komponenty, počet ve frontě přes `useBuddyQueuedRunCount`, terminál přes `buddyTerminalUiState` a bez `ChatTerminalDrawers`, pravý panel přes `buddyRightPanelState` a bez záložek vlákna z `useLazurioThreadTabs`), `QueuedRunsControl.tsx` (`useBuddyQueuedRuns`) a `__root.tsx`; full-access Buddyho vlákna drží na serveru stráž příkazů a cesta vlákna řádku 25. Stav terminálu a panelu se čte uvnitř selektorů úložišť (Lazurio/t3code#134), což hlídá `chatViewPanelPresence.test.ts`. Na v0.1.3 upstream přesunul práci tahu a frontu na konec časové osy a seznam úkolů smazal (#25401): ChatView maskuje `childInputNow`, `goalNow` a `backgroundWorkNow` inline podmínkami (žádná obyčejná funkce kolem výsledku háčku, Lazurio/t3code#135), `buddyBackgroundWork` je to, zda `backgroundWorkNow` existuje, počet ve frontě nepočítá frontové probuzení Delegace, které `getUserQueuedThreadRuns` upstreamu nechává, a šev seznamu úkolů odpadl. T3 už motiv neaplikuje z efektu `useTheme` (#25007, #25461), proto náhrada vzhledu hostitele v bublině následuje každou aplikaci uloženého motivu (`subscribeRenderedAppearance`). Na v0.1.4 upstream zrušil odpočívající stav composeru (#25869), takže šev pásu pod composerem odpadl, a paint-only časovou osu (#25787), takže `buddyBackgroundWork` jde přímo do `MessagesTimeline`. Fronta už nepřeřazuje (#25846) a nese odesílatele (#26159); `useBuddyQueuedRuns` ji dál zužuje na zprávy člověka. Čekající schválení upstream ukazuje na jeho řádku práce a v patičce časové osy jen to, které řádek nemá (#26255, `MessagesTimeline.tsx`, `unmatchedPendingApprovals`); Buddyho povrch řádky práce vyřadí, takže všechna schválení padnou do patičky, což hlídá `buddySurfaceTimeline.browser.test.tsx`. Karta žádosti o propojení Environmentu (`link_request`, #17129) na Buddyho povrchu chybí, protože `isForThePerson` z řádků událostí nechává jen `secret_request`, a je to tak správně: Buddyho T3 Code propojené Environmenty vypíná (řádek 25), takže žádost nevznikne. Typ zkratek se bere z `Parameters[0]` (#26238). Při přestavbě ověřte, že časová osa dál vzniká z řádků `deriveMessagesTimelineRows`, že nepovedený tah nese položka `error` se stavem `failed` bez rodiče, že všechny ovládací prvky composeru dál kreslí jediná `ComposerControlsBar`, že volby poskytovatele dál zapisuje `setProviderModelOptions` a že práci na pozadí, cíl a otázku podvlákna dál dodává `useThreadLifecycle` jako položky pro `ThreadNow`. Ověřte i, že terminál dál kreslí jen `ChatTerminalDrawers`, pravý panel jen `ChatRightPanel` podle stavu, který ChatView čte, a že webové odkazy chatu dál nesou `target="_blank"` a jejich handlery v T3 naslouchají pod oknem, kde je Buddyho povrch předběhne. Na v0.1.5 upstream přesunul `PendingUserInputDraftAnswer` do `client-runtime` (#26167); overlay ho nepoužívá. Na v0.1.6 vrací `useThreadLifecycle` `attentionNow` (Stop běhu, který zůstal bez odpovědi, Force stop #27252, jinak otázku podřízeného vlákna) a `workNow` (Stop, který probíhá, jinak práci na pozadí); `backgroundWorkNow` zmizel. Inline maska na Buddyho povrchu skryje otázku podřízeného, práci i cíl, ale Stop bez odpovědi tam zůstane vidět, aby ho člověk mohl vynutit; kontraktní test pinuje každý řádek masky (React Compiler, Lazurio/t3code#135) i návratovou hodnotu `useThreadLifecycle`. `renderProviderTraitsMenuContent` upstreamu (#28057, #28076) `ComposerControlsBar` nepotřebuje, protože na Buddyho povrchu dřív vrátí `BuddyComposerControls`. Postranní chat vykreslí `ChatView` vložený, takže záložky vlákna a terminál jsou pro něj vypnuté jako na Buddyho povrchu. Na v0.1.7 obaluje upstream časovou osu `WorkspaceMutationIdContext`, takže `buddyBackgroundWork` stojí uvnitř, po `isWorking`. Upstream sám předává `environmentId` pruhu bannerů, overlay proto vlastní kopii té vlastnosti zahodil a používá ji jen pro chybový banner Buddyho. Řádek práce mimo Buddyho zní na v0.1.7 „Running ·