@skanl/brambo-session 0.1.1

package/dist/tool-executor.js

@@ -0,0 +1,159 @@
+import { BRAMBO_ERROR_CODES, BramboError, validateSandboxExecutionRequest, validateToolExecutionContext, validateToolInvocationForExecution, validateToolResult } from '@skanl/brambo-contracts';
+const MCP_PROTOCOL_VERSION = '2024-11-05';
+function invalidResponse(message) {
+    return new BramboError(BRAMBO_ERROR_CODES.sandboxResponseInvalid, `invalid MCP response: ${message}`);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.length > 0;
+}
+function validateError(value) {
+    if (!isRecord(value) || !Number.isInteger(value['code']) || !isNonEmptyString(value['message'])) {
+        throw invalidResponse('error must contain an integer code and non-empty message');
+    }
+}
+function parseResponse(frame, expectedId) {
+    let value;
+    try {
+        value = JSON.parse(frame);
+    }
+    catch (error) {
+        throw invalidResponse(`frame is not JSON (${error instanceof Error ? error.message : 'parse failure'})`);
+    }
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        throw invalidResponse('response must be an object');
+    const response = value;
+    if (response['jsonrpc'] !== '2.0')
+        throw invalidResponse("response 'jsonrpc' must be '2.0'");
+    if (response['id'] !== expectedId)
+        throw invalidResponse(`response id does not match request ${expectedId}`);
+    const hasResult = Object.hasOwn(response, 'result');
+    const hasError = Object.hasOwn(response, 'error');
+    if (hasResult === hasError)
+        throw invalidResponse('response must contain exactly one of result or error');
+    if (hasError)
+        validateError(response['error']);
+    return response;
+}
+function validateInitializeResult(value) {
+    if (!isRecord(value))
+        throw invalidResponse("initialize result must be an object");
+    const serverInfo = value['serverInfo'];
+    if (!isNonEmptyString(value['protocolVersion']))
+        throw invalidResponse("initialize result 'protocolVersion' must be a non-empty string");
+    if (!isRecord(value['capabilities']))
+        throw invalidResponse("initialize result 'capabilities' must be an object");
+    if (!isRecord(serverInfo) || !isNonEmptyString(serverInfo['name']) || !isNonEmptyString(serverInfo['version'])) {
+        throw invalidResponse("initialize result 'serverInfo' must contain non-empty name and version strings");
+    }
+    if (value['instructions'] !== undefined && typeof value['instructions'] !== 'string') {
+        throw invalidResponse("initialize result 'instructions' must be a string when present");
+    }
+}
+function validateToolCallResult(value) {
+    if (!isRecord(value) || !Array.isArray(value['content']))
+        throw invalidResponse("tools/call result 'content' must be an array");
+    for (const [index, content] of value['content'].entries()) {
+        if (!isRecord(content) || !isNonEmptyString(content['type'])) {
+            throw invalidResponse(`tools/call result content[${index}] must contain a non-empty type string`);
+        }
+        if (content['type'] === 'text' && typeof content['text'] !== 'string') {
+            throw invalidResponse(`tools/call result content[${index}] text must be a string`);
+        }
+    }
+    if (value['isError'] !== undefined && typeof value['isError'] !== 'boolean') {
+        throw invalidResponse("tools/call result 'isError' must be a boolean when present");
+    }
+    if (value['structuredContent'] !== undefined && !isRecord(value['structuredContent'])) {
+        throw invalidResponse("tools/call result 'structuredContent' must be an object when present");
+    }
+}
+function validateResult(method, value) {
+    if (method === 'initialize') {
+        validateInitializeResult(value);
+        return;
+    }
+    if (method === 'tools/call')
+        validateToolCallResult(value);
+}
+async function request(stdio, id, method, params, signal) {
+    await stdio.sendFrame(JSON.stringify({ jsonrpc: '2.0', id, method, params }), signal);
+    const response = parseResponse(await stdio.receiveFrame(signal), id);
+    if (Object.hasOwn(response, 'error')) {
+        throw new BramboError(BRAMBO_ERROR_CODES.executorRunFailed, `MCP request '${method}' failed`);
+    }
+    validateResult(method, response['result']);
+    return response;
+}
+function mcpResult(session, value) {
+    return validateToolResult({
+        status: 'ok',
+        stdout: JSON.stringify(value),
+        stderr: '',
+        exitCode: 0,
+        enforcement: session.capabilities ?? {
+            version: 1,
+            providerId: session.providerId,
+            enforcement: 'simulated',
+            controls: { filesystem: 'none', network: 'none', process: 'none', resources: 'none' },
+        },
+    });
+}
+async function executeMcp(session, invocation, context) {
+    const requestContext = validateToolExecutionContext(context);
+    const sandboxRequest = validateSandboxExecutionRequest({ ...requestContext, argv: [...invocation.tool.argv] });
+    if (typeof session.openStdio !== 'function') {
+        throw new BramboError(BRAMBO_ERROR_CODES.sandboxUnavailable, `sandbox session '${session.id}' does not expose stdio`);
+    }
+    const stdio = await session.openStdio(sandboxRequest);
+    try {
+        await requestMcp(stdio, sandboxRequest.signal);
+        const response = await request(stdio, 2, 'tools/call', { name: invocation.tool.name, arguments: invocation.arguments }, sandboxRequest.signal);
+        return mcpResult(session, response['result']);
+    }
+    finally {
+        await stdio.close();
+    }
+}
+async function requestMcp(stdio, signal) {
+    await request(stdio, 1, 'initialize', {
+        protocolVersion: MCP_PROTOCOL_VERSION,
+        capabilities: {},
+        clientInfo: { name: 'brambo', version: '0.1.0' },
+    }, signal);
+    await stdio.sendFrame(JSON.stringify({ jsonrpc: '2.0', method: 'notifications/initialized', params: {} }), signal);
+}
+/**
+ * Binds a caller-owned sandbox session to tool execution. Discovery stays
+ * elsewhere: accepting a ToolProvider here would turn listing into authority.
+ * This executor never owns or disposes the supplied session.
+ */
+async function executeRemoteMcp(client, invocation, context, session) {
+    if (client === undefined)
+        throw new BramboError(BRAMBO_ERROR_CODES.sandboxUnavailable, 'remote MCP execution requires an injected client');
+    const executionContext = validateToolExecutionContext(context);
+    const response = await client.request(invocation.tool.url, 'tools/call', { name: invocation.tool.name, arguments: invocation.arguments }, executionContext.signal);
+    return mcpResult(session, response.result);
+}
+export function createToolExecutor(session, remoteMcpClient) {
+    return Object.freeze({
+        async execute(invocation, context) {
+            // Both validations finish before the first await and therefore before the
+            // sandbox provider can create or signal a process.
+            const executionContext = validateToolExecutionContext(context);
+            const tool = validateToolInvocationForExecution(invocation, executionContext);
+            if (tool.tool.kind === 'mcp-stdio')
+                return executeMcp(session, tool, context);
+            if (tool.tool.kind === 'mcp-streamable-http')
+                return executeRemoteMcp(remoteMcpClient, tool, context, session);
+            const localInvocation = tool;
+            const request = validateSandboxExecutionRequest({
+                ...executionContext,
+                argv: [...localInvocation.tool.argv, ...localInvocation.arguments],
+            });
+            return validateToolResult(await session.execute(request));
+        },
+    });
+}

package/dist/usage.d.ts

@@ -0,0 +1,30 @@
+import type { UsageReport } from '@skanl/brambo-contracts';
+/** Where the observations live: brambo's own directory, one document. */
+export declare function usageObservationsPath(homeDir?: string): string;
+export interface UsageStoreOptions {
+    /** Root of the machine scope; `<homeDir>/.brambo` is brambo's own directory. */
+    readonly homeDir?: string;
+}
+/**
+ * Writes down what one run observed, replacing that executor's previous reading.
+ *
+ * One reading per executor and no history: the question `brambo status` answers is
+ * "how much is left", which only the NEWEST reading answers. A log of past
+ * utilisations is a different feature, and nothing reads it.
+ *
+ * ponytail: read-modify-write, not atomic. Two `brambo run` invocations finishing
+ * in the same instant can lose one of the two observations, which costs a stale
+ * row until the next run. Upgrade path: write to a sibling temp file and rename,
+ * the way `@skanl/brambo-projection` writes ledgers, if concurrent runs become normal.
+ */
+export declare function recordUsageObservation(report: UsageReport, options?: UsageStoreOptions): Promise<void>;
+/**
+ * One report per executor brambo ships, in catalogue order. Reads only; it
+ * invokes nothing and writes nothing (D6/D7).
+ *
+ * Three answers, and every one of them is TYPED (AD-5). There is deliberately no
+ * fourth answer in which a row is blank or reads `0`: a zero for an executor
+ * brambo cannot measure is worse than no row, because it looks like a measurement
+ * that was taken.
+ */
+export declare function readUsageReports(options?: UsageStoreOptions): Promise<readonly UsageReport[]>;

package/dist/usage.js

@@ -0,0 +1,110 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { EXECUTOR_CATALOGUE } from '@skanl/brambo-adapter-cli';
+import { USAGE_ABSENCE_REASONS, isUsageReport, usageAbsence } from '@skanl/brambo-contracts';
+// The recorded side of Story M15.A's D7.
+//
+// A quota reading arrives DURING a real invocation, so a report that took one
+// would cost the user the very thing it reports on — and would be unrunnable on
+// exactly the day they most want it. So the run that already paid for the number
+// writes it down, and the report reads what was written. Writing it costs
+// nothing more, and the report answers instantly and offline.
+//
+// What is stored is an OBSERVATION, not a measurement brambo owns: the vendor's
+// own window names, the vendor's own numbers, plus the instant brambo read them.
+// A utilisation is only true as of its reading.
+const STORE_VERSION = 1;
+/** Where the observations live: brambo's own directory, one document. */
+export function usageObservationsPath(homeDir = homedir()) {
+    return join(homeDir, '.brambo', 'usage-observations.json');
+}
+/**
+ * What the document holds, keyed by executor id, or an empty map.
+ *
+ * Unreadable, unparseable, or stamped with a version this build does not speak
+ * all mean the same thing here and it is not a failure: brambo has no observation
+ * to report, which `readUsageReports` already states as typed absence. This is a
+ * CACHE of readings brambo can take again by running; refusing to answer because
+ * of it would be the report failing over its own bookkeeping.
+ */
+async function readStored(path) {
+    let text;
+    try {
+        text = await readFile(path, 'utf8');
+    }
+    catch {
+        return {};
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return {};
+    }
+    const document = parsed;
+    if (document === null || typeof document !== 'object' || document.version !== STORE_VERSION)
+        return {};
+    const reports = document.reports;
+    if (reports === null || typeof reports !== 'object')
+        return {};
+    const kept = {};
+    for (const [executorId, report] of Object.entries(reports)) {
+        // Per ENTRY, not per document: one record brambo can no longer understand
+        // must not throw away the others beside it.
+        if (isUsageReport(report) && report.executorId === executorId)
+            kept[executorId] = report;
+    }
+    return kept;
+}
+/**
+ * Writes down what one run observed, replacing that executor's previous reading.
+ *
+ * One reading per executor and no history: the question `brambo status` answers is
+ * "how much is left", which only the NEWEST reading answers. A log of past
+ * utilisations is a different feature, and nothing reads it.
+ *
+ * ponytail: read-modify-write, not atomic. Two `brambo run` invocations finishing
+ * in the same instant can lose one of the two observations, which costs a stale
+ * row until the next run. Upgrade path: write to a sibling temp file and rename,
+ * the way `@skanl/brambo-projection` writes ledgers, if concurrent runs become normal.
+ */
+export async function recordUsageObservation(report, options = {}) {
+    const path = usageObservationsPath(options.homeDir);
+    const reports = { ...(await readStored(path)), [report.executorId]: report };
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, `${JSON.stringify({ version: STORE_VERSION, reports }, null, 2)}\n`, 'utf8');
+}
+/**
+ * One report per executor brambo ships, in catalogue order. Reads only; it
+ * invokes nothing and writes nothing (D6/D7).
+ *
+ * Three answers, and every one of them is TYPED (AD-5). There is deliberately no
+ * fourth answer in which a row is blank or reads `0`: a zero for an executor
+ * brambo cannot measure is worse than no row, because it looks like a measurement
+ * that was taken.
+ */
+export async function readUsageReports(options = {}) {
+    const stored = await readStored(usageObservationsPath(options.homeDir));
+    return [...EXECUTOR_CATALOGUE.entries()].map(([executorId, shipped]) => {
+        // Derived from the trait record rather than from a list of executor names
+        // written beside it — the parallel-name-list defect this repo has already
+        // shipped once. An executor gains a quota row by declaring a surface.
+        if (shipped.traits.output.usageWindows === undefined) {
+            return usageAbsence(executorId, USAGE_ABSENCE_REASONS.noUsageSurface, `executor '${executorId}' publishes no usage surface in its output, so brambo has no reading to report for it`);
+        }
+        return (stored[executorId] ??
+            usageAbsence(executorId, USAGE_ABSENCE_REASONS.notObserved, 
+            // Deliberately does NOT open with brambo's own name. The sentence is a
+            // template literal, and packages/cli/test/printed-commands.test.ts reads
+            // an opening backtick followed by that name as a COMMAND — so a sentence
+            // beginning with it is scanned as a verb that does not exist. Measured:
+            // the earlier wording turned this into a fabricated two-word command and
+            // reddened that invariant.
+            //
+            // The command this DOES name is backticked on purpose, so the same
+            // invariant dispatches it and E4's exit cannot rot into prose.
+            `no usage reading has been recorded for '${executorId}' yet; \`brambo run "<prompt>" --executor ${executorId}\` records one`));
+    });
+}

package/dist/workspaces.d.ts

@@ -0,0 +1,63 @@
+import type { ConfigLayer, LayeredConfig } from '@skanl/brambo-kernel';
+import type { WorkspacePlugin } from '@skanl/brambo-workspace-local';
+/** The key inside the `workspace` subtree that names the provider. */
+export declare const WORKSPACE_PROVIDER_CONFIG_KEY = "provider";
+/**
+ * Where a project's workspaces live: the `workspace.rootDir` `runSession` seeds,
+ * as ONE function rather than two `join` calls.
+ *
+ * It exists because a second caller arrived. `brambo workspace remove` has to
+ * find the ledger and the trees a run created, and a CLI that spelled
+ * `.brambo/workspaces` for itself would be a second answer to where brambo's
+ * worktrees are — right until a run wrote them somewhere else. The session
+ * decides this path; everyone else asks.
+ */
+export declare function worktreeStateDir(projectRoot: string): string;
+/** What brambo mounts when nothing selects otherwise. */
+export declare const DEFAULT_WORKSPACE_PROVIDER_ID = "local";
+/** The `git worktree`-backed provider (`@skanl/brambo-workspace-git-worktree`). */
+export declare const GIT_WORKTREE_PROVIDER_ID = "git-worktree";
+/**
+ * What the mount needs that no configuration document supplies.
+ *
+ * `repoPath` is the repository worktrees are cut from. It is a MOUNT input
+ * rather than a config key because it is not a choice a user makes in a
+ * document — it is the project the host is already running in, the same `cwd`
+ * `workspace.rootDir` is computed from. See the plugin's own note.
+ */
+export interface WorkspaceMountContext {
+    readonly repoPath: string;
+}
+/** Every provider id a selection may name, in catalogue order. */
+export declare function availableWorkspaceProviderIds(): readonly string[];
+export interface WorkspaceProviderSelection {
+    /** The id that won; always a key of the catalogue. */
+    readonly providerId: string;
+    /**
+     * The layer that supplied it, taken from the layered config's OWN `dump()`.
+     * Never recomputed: provenance derived a second time is how a report starts
+     * disagreeing with the thing it reports on.
+     */
+    readonly layer: ConfigLayer;
+    /** Every id a selection may name, for a host that has to render a choice. */
+    readonly available: readonly string[];
+}
+/**
+ * The workspace provider an already-seeded configuration decides, with the layer
+ * that decided it. Pure: it reads the composed view and touches no file.
+ *
+ * Reading the filesystem here is the thing this must not do. `executors.ts`
+ * states the rule for its twin: a session primitive whose behaviour depends on
+ * files under the running user's home is not usable from a host that already
+ * knows what it wants. The caller seeds layers; this reads the composed view.
+ */
+export declare function selectWorkspaceProvider(config: LayeredConfig): WorkspaceProviderSelection;
+/**
+ * The plugin for one catalogue id.
+ *
+ * Separate from the selection so the selection stays a pure value a host can
+ * report on without constructing anything — and so there is exactly one place a
+ * provider id turns into a plugin. An id the catalogue does not hold is a coded
+ * failure, never a fallback.
+ */
+export declare function createSelectedWorkspacePlugin(providerId: string, context: WorkspaceMountContext): WorkspacePlugin;

package/dist/workspaces.js

@@ -0,0 +1,126 @@
+import { join } from 'node:path';
+import { BRAMBO_ERROR_CODES, BramboError } from '@skanl/brambo-contracts';
+import { createGitWorktreeWorkspacePlugin } from '@skanl/brambo-workspace-git-worktree';
+import { WORKSPACE_CONFIG_KEY, createWorkspacePlugin } from '@skanl/brambo-workspace-local';
+// Workspace provider SELECTION: which shipped `WorkspaceProvider` this run
+// mounts, decided through the layered configuration brambo already owns.
+//
+// It is the executor selection's twin on purpose (`executors.ts`), down to
+// taking the value and its layer from ONE `dump()` entry. What differs is only
+// the key path: `workspace` is ALREADY an object-namespaced subtree — the
+// session seeds `workspace.rootDir` into it as a layer — so the selection
+// belongs at `workspace.provider` rather than at a second root key that would
+// split one plugin's configuration across two places.
+//
+// Two plugins providing the service `workspace` would be
+// `BRAMBO_KERNEL_SERVICE_CONFLICT`, so this does not compose providers: it
+// CHOOSES one, and the chosen one is the only one registered.
+/** The key inside the `workspace` subtree that names the provider. */
+export const WORKSPACE_PROVIDER_CONFIG_KEY = 'provider';
+/**
+ * Where a project's workspaces live: the `workspace.rootDir` `runSession` seeds,
+ * as ONE function rather than two `join` calls.
+ *
+ * It exists because a second caller arrived. `brambo workspace remove` has to
+ * find the ledger and the trees a run created, and a CLI that spelled
+ * `.brambo/workspaces` for itself would be a second answer to where brambo's
+ * worktrees are — right until a run wrote them somewhere else. The session
+ * decides this path; everyone else asks.
+ */
+export function worktreeStateDir(projectRoot) {
+    return join(projectRoot, '.brambo', 'workspaces');
+}
+/** What brambo mounts when nothing selects otherwise. */
+export const DEFAULT_WORKSPACE_PROVIDER_ID = 'local';
+/** The `git worktree`-backed provider (`@skanl/brambo-workspace-git-worktree`). */
+export const GIT_WORKTREE_PROVIDER_ID = 'git-worktree';
+/**
+ * Every workspace provider brambo ships, keyed by the id a document may name.
+ *
+ * A MAP from id to plugin factory, not a set of ids beside a `switch`. That
+ * shape is the one `EXECUTOR_CATALOGUE` arrived at after a parallel name list
+ * drifted from the thing it named and shipped an executor nothing ever
+ * exercised: here the id list, the closed-catalogue check and the mount are all
+ * read out of this one object, so an id cannot exist without a factory and a
+ * factory cannot be unreachable by name.
+ */
+const WORKSPACE_PROVIDER_CATALOGUE = new Map([
+    // The local plugin takes its `rootDir` from the composed document and needs
+    // nothing from the mount, which is why it ignores the context rather than
+    // being handed a narrower one.
+    [DEFAULT_WORKSPACE_PROVIDER_ID, () => createWorkspacePlugin()],
+    [GIT_WORKTREE_PROVIDER_ID, ({ repoPath }) => createGitWorktreeWorkspacePlugin({ repoPath })],
+]);
+/** Every provider id a selection may name, in catalogue order. */
+export function availableWorkspaceProviderIds() {
+    return [...WORKSPACE_PROVIDER_CATALOGUE.keys()];
+}
+const DOTTED_KEY = `${WORKSPACE_CONFIG_KEY}.${WORKSPACE_PROVIDER_CONFIG_KEY}`;
+function unusableSelection(detail) {
+    // `configurationUnusable` rather than a new code: brambo's own document exists
+    // and holds a value brambo cannot use, which is exactly what that code is for
+    // (see its note in `@skanl/brambo-contracts`). There is no workspace twin of
+    // `BRAMBO_EXECUTOR_NOT_FOUND` and this story does not invent one — the message
+    // carries the closed catalogue, which is the half a user acts on.
+    return new BramboError(BRAMBO_ERROR_CODES.configurationUnusable, `brambo's '${DOTTED_KEY}' configuration cannot be used: ${detail}`);
+}
+/**
+ * The catalogue's refusal for a name brambo ships no provider under.
+ *
+ * ONE spelling, called from the selection and from the mount, because the two
+ * would otherwise drift — the failure `EXECUTOR_CATALOGUE`'s own note records.
+ */
+function unknownWorkspaceProvider(providerId) {
+    return unusableSelection(`brambo has no workspace provider named '${providerId}'; available providers: ${availableWorkspaceProviderIds().join(', ')}`);
+}
+/**
+ * The workspace provider an already-seeded configuration decides, with the layer
+ * that decided it. Pure: it reads the composed view and touches no file.
+ *
+ * Reading the filesystem here is the thing this must not do. `executors.ts`
+ * states the rule for its twin: a session primitive whose behaviour depends on
+ * files under the running user's home is not usable from a host that already
+ * knows what it wants. The caller seeds layers; this reads the composed view.
+ */
+export function selectWorkspaceProvider(config) {
+    // The value AND its provenance from ONE dump entry, so the two cannot disagree.
+    const decided = config
+        .dump()
+        .find((entry) => entry.path.length === 2 &&
+        entry.path[0] === WORKSPACE_CONFIG_KEY &&
+        entry.path[1] === WORKSPACE_PROVIDER_CONFIG_KEY);
+    if (decided === undefined) {
+        // Reachable, unlike its executor twin: `dump()` reports LEAVES, so a
+        // document writing an OBJECT at this path leaves no entry here at all. A
+        // default taken on this path would mount `local` for a user whose document
+        // says something else — silently running somewhere other than where they
+        // asked, which is the failure the whole selection exists to remove.
+        throw unusableSelection(`no provider is resolvable at this path (a '${DOTTED_KEY}' that is an object rather than one of: ${availableWorkspaceProviderIds().join(', ')} does this)`);
+    }
+    if (typeof decided.value !== 'string') {
+        // Type-checked, never coerced: `String(42)` would turn a typo into the
+        // catalogue lookup's problem and report it as an unknown provider name.
+        throw unusableSelection(`it must be a string naming one of: ${availableWorkspaceProviderIds().join(', ')}, but the '${decided.layer}' layer supplies ${typeof decided.value}`);
+    }
+    if (!WORKSPACE_PROVIDER_CATALOGUE.has(decided.value))
+        throw unknownWorkspaceProvider(decided.value);
+    return {
+        providerId: decided.value,
+        layer: decided.layer,
+        available: availableWorkspaceProviderIds(),
+    };
+}
+/**
+ * The plugin for one catalogue id.
+ *
+ * Separate from the selection so the selection stays a pure value a host can
+ * report on without constructing anything — and so there is exactly one place a
+ * provider id turns into a plugin. An id the catalogue does not hold is a coded
+ * failure, never a fallback.
+ */
+export function createSelectedWorkspacePlugin(providerId, context) {
+    const factory = WORKSPACE_PROVIDER_CATALOGUE.get(providerId);
+    if (factory === undefined)
+        throw unknownWorkspaceProvider(providerId);
+    return factory(context);
+}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@skanl/brambo-session",
+  "version": "0.1.1",
+  "description": "The brambo session: everything `brambo run` does except argv, JSON and exit codes.",
+  "keywords": [
+    "ai-agent",
+    "brambo",
+    "session",
+    "orchestration",
+    "executor"
+  ],
+  "homepage": "https://github.com/SKANL/brambo#readme",
+  "bugs": {
+    "url": "https://github.com/SKANL/brambo/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SKANL/brambo.git",
+    "directory": "packages/session"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=20"
+  },
+  "exports": {
+    ".": {
+      "brambo-source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@skanl/brambo-adapter-cli": "0.1.1",
+    "@skanl/brambo-contracts": "0.1.1",
+    "@skanl/brambo-kernel": "0.1.1",
+    "@skanl/brambo-sandbox": "0.1.1",
+    "@skanl/brambo-workspace-git-worktree": "0.1.1",
+    "@skanl/brambo-workspace-local": "0.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^24.13.3",
+    "rolldown": "1.2.5",
+    "typescript": "~7.0.2",
+    "vitest": "^4.1.11"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "lint": "eslint .",
+    "build": "node ../../scripts/clean-dist.mjs && tsc -p tsconfig.build.json"
+  }
+}