@lensagent/core 0.1.0

package/dist/runtime/projects.js

@@ -0,0 +1,115 @@
+import { CapabilityRegistry } from './capabilities.js';
+import { CallRuntime } from './calls.js';
+import { ContextEngine } from './context.js';
+import { AgentRuntime } from './agent.js';
+import { KernelAdapter, kernelCapabilities } from './kernel-capabilities.js';
+import { workspaceSkills } from './skills.js';
+import { coreManifests, manifestSetDigest } from './manifests.js';
+export class ProjectRuntimes {
+    store;
+    config;
+    scheduler;
+    artifacts;
+    models;
+    reviewer;
+    sharedCapabilities;
+    target;
+    events;
+    pinnedProjectId;
+    #runtimes = new Map();
+    #evictionTimer;
+    #closed = false;
+    constructor(store, config, scheduler, artifacts, models, reviewer, sharedCapabilities, target, events, pinnedProjectId) {
+        this.store = store;
+        this.config = config;
+        this.scheduler = scheduler;
+        this.artifacts = artifacts;
+        this.models = models;
+        this.reviewer = reviewer;
+        this.sharedCapabilities = sharedCapabilities;
+        this.target = target;
+        this.events = events;
+        this.pinnedProjectId = pinnedProjectId;
+    }
+    get(projectId) {
+        if (this.#closed)
+            throw new Error('Project runtimes are closed.');
+        this.store.getProject(projectId);
+        const existing = this.#runtimes.get(projectId);
+        if (existing !== undefined) {
+            existing.lastAccessedAt = Date.now();
+            return existing.runtime;
+        }
+        const runtime = this.#build(projectId);
+        this.#runtimes.set(projectId, { runtime, lastAccessedAt: Date.now() });
+        return runtime;
+    }
+    refresh(projectId) {
+        this.#runtimes.get(projectId)?.runtime.refreshSkills();
+    }
+    startIdleEviction(maxIdleMs = 30 * 60 * 1000) {
+        if (this.#evictionTimer !== undefined || this.#closed)
+            return;
+        this.#evictionTimer = setInterval(() => { void this.#evictIdle(maxIdleMs); }, Math.min(maxIdleMs, 5 * 60 * 1000));
+        this.#evictionTimer.unref();
+    }
+    async close() {
+        this.#closed = true;
+        if (this.#evictionTimer !== undefined)
+            clearInterval(this.#evictionTimer);
+        this.#evictionTimer = undefined;
+        const runtimes = [...this.#runtimes.values()].map((entry) => entry.runtime);
+        this.#runtimes.clear();
+        await Promise.allSettled(runtimes.flatMap((runtime) => [runtime.agents.close(), runtime.calls.close()]));
+    }
+    async #evictIdle(maxIdleMs) {
+        const timestamp = Date.now();
+        for (const [projectId, entry] of this.#runtimes) {
+            if (this.#closed || projectId === this.pinnedProjectId || timestamp - entry.lastAccessedAt < maxIdleMs)
+                continue;
+            if (this.store.hasActiveRuntimeObjects(projectId)) {
+                entry.lastAccessedAt = timestamp;
+                continue;
+            }
+            const lastAccessedAt = entry.lastAccessedAt;
+            await Promise.allSettled([entry.runtime.agents.close(), entry.runtime.calls.close()]);
+            if (entry.lastAccessedAt === lastAccessedAt && !this.store.hasActiveRuntimeObjects(projectId))
+                this.#runtimes.delete(projectId);
+        }
+    }
+    #build(projectId) {
+        const registry = new CapabilityRegistry(this.target);
+        for (const capability of this.sharedCapabilities)
+            registry.register(capability);
+        const context = new ContextEngine(this.store, registry);
+        const calls = new CallRuntime(this.store, registry, this.scheduler, this.artifacts, this.events);
+        const agents = new AgentRuntime(this.store, this.config, context, this.models, registry, calls, this.reviewer, this.events);
+        const kernel = new KernelAdapter(this.store, registry, this.config, (targetProjectId, agentId) => this.get(targetProjectId).agents.wake(targetProjectId, agentId), (targetProjectId, input, signal) => this.get(targetProjectId).agents.createSubagent(targetProjectId, input, signal));
+        for (const capability of kernelCapabilities(kernel))
+            registry.register(capability);
+        const refreshSkills = () => {
+            registry.removeKind('skill');
+            const paths = this.store.listWorkspaces(projectId).flatMap((workspace) => {
+                const value = workspace.paths;
+                return Array.isArray(value) ? value.filter((entry) => typeof entry === 'string') : [];
+            });
+            for (const capability of workspaceSkills(paths))
+                registry.register(capability);
+        };
+        refreshSkills();
+        for (const callId of this.store.queuedDirectCallIds(projectId))
+            calls.dispatch(projectId, callId);
+        return {
+            projectId,
+            registry,
+            calls,
+            context,
+            agents,
+            refreshSkills,
+            contractDigest: () => manifestSetDigest([
+                ...coreManifests(this.config.current.config),
+                ...registry.contractManifests()
+            ], this.target)
+        };
+    }
+}

package/dist/runtime/results.d.ts

@@ -0,0 +1,7 @@
+import { type ArtifactOutput, type CapabilityOutput, type Json } from '../core/domain.js';
+export interface NormalizedOutput {
+    readonly content: Json;
+    readonly artifacts: readonly ArtifactOutput[];
+    readonly truncated: boolean;
+}
+export declare function normalizeOutput(output: CapabilityOutput, limit: number): NormalizedOutput;

package/dist/runtime/results.js

@@ -0,0 +1,55 @@
+import { canonicalize } from 'json-canonicalize';
+import { fail } from '../core/domain.js';
+export function normalizeOutput(output, limit) {
+    if (!Number.isSafeInteger(limit) || limit <= 0)
+        fail('RESULT_NORMALIZATION_FAILED', 422, 'Capability output limit is invalid.');
+    let remaining = limit;
+    let truncated = false;
+    let content = null;
+    const artifacts = [];
+    const serialized = Buffer.from(typeof output.content === 'string' ? output.content : canonicalize(output.content));
+    if (serialized.byteLength <= Math.min(remaining, 65536)) {
+        content = structuredClone(output.content);
+        remaining -= serialized.byteLength;
+    }
+    else if (serialized.byteLength <= remaining) {
+        artifacts.push({
+            name: typeof output.content === 'string' ? 'result.txt' : 'result.json',
+            mediaType: typeof output.content === 'string' ? 'text/plain; charset=utf-8' : 'application/json',
+            bytes: serialized
+        });
+        remaining -= serialized.byteLength;
+    }
+    else if (typeof output.content === 'string') {
+        const bytes = utf8Prefix(serialized, remaining);
+        if (bytes.byteLength > 0)
+            artifacts.push({ name: 'result.txt', mediaType: 'text/plain; charset=utf-8', bytes });
+        remaining -= bytes.byteLength;
+        truncated = true;
+    }
+    else {
+        truncated = true;
+    }
+    for (const artifact of output.artifacts ?? []) {
+        if (artifact.bytes.byteLength <= remaining) {
+            artifacts.push({ ...artifact, bytes: Uint8Array.from(artifact.bytes) });
+            remaining -= artifact.bytes.byteLength;
+        }
+        else
+            truncated = true;
+    }
+    return { content, artifacts, truncated };
+}
+function utf8Prefix(bytes, limit) {
+    for (let end = Math.min(bytes.byteLength, limit); end >= Math.max(0, limit - 3); end -= 1) {
+        const candidate = bytes.subarray(0, end);
+        try {
+            new TextDecoder('utf-8', { fatal: true }).decode(candidate);
+            return Uint8Array.from(candidate);
+        }
+        catch {
+            // Try the previous byte boundary until the prefix is valid UTF-8.
+        }
+    }
+    return new Uint8Array();
+}

package/dist/runtime/review.d.ts

@@ -0,0 +1,9 @@
+import type { ConfigRuntime } from '../config/runtime.js';
+import type { Document } from '../store/store.js';
+import type { AiModelGateway } from './model.js';
+export declare class AutoReviewer {
+    readonly gateway: AiModelGateway;
+    readonly config: ConfigRuntime;
+    constructor(gateway: AiModelGateway, config: ConfigRuntime);
+    review(goal: string, call: Document, signal: AbortSignal): Promise<boolean>;
+}

package/dist/runtime/review.js

@@ -0,0 +1,54 @@
+import { fail } from '../core/domain.js';
+import { resolveReasoningEffort } from './profile.js';
+export class AutoReviewer {
+    gateway;
+    config;
+    constructor(gateway, config) {
+        this.gateway = gateway;
+        this.config = config;
+    }
+    async review(goal, call, signal) {
+        const snapshot = this.config.current;
+        const role = snapshot.config.roles['auto-review'];
+        if (role.model === null)
+            fail('CONFIG_INVALID', 503, 'The auto-review role requires a model.');
+        const primaryModel = role.model;
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(new Error('Auto Review timed out.')), snapshot.config.autoReview.timeoutMs);
+        signal.addEventListener('abort', () => controller.abort(signal.reason), { once: true });
+        const messages = [
+            { role: 'system', content: 'Review the proposed capability call against the user goal. Return only {"decision":"approve"} or {"decision":"reject"}.' },
+            { role: 'user', content: JSON.stringify({ goal: bounded(goal, snapshot.config.autoReview.goalMaxBytes), call }) }
+        ];
+        const candidates = [...Array.from({ length: role.providerRouting.retryMaxAttempts }, () => primaryModel), ...role.providerRouting.fallback];
+        try {
+            for (const model of candidates) {
+                let response = '';
+                try {
+                    const resolved = this.gateway.resolve(model, snapshot.config);
+                    for await (const event of this.gateway.stream({ model, reasoningEffort: resolveReasoningEffort(resolved.profile, role.modelReasoningEffort), maxOutputTokens: 64, signal: controller.signal, tools: [], messages }, snapshot.config)) {
+                        if (event.type === 'text')
+                            response += event.text;
+                    }
+                    const decision = JSON.parse(response);
+                    if (decision.decision === 'approve')
+                        return true;
+                    if (decision.decision === 'reject')
+                        return false;
+                }
+                catch {
+                    if (controller.signal.aborted)
+                        return false;
+                }
+            }
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+        return false;
+    }
+}
+function bounded(value, maximum) {
+    const bytes = Buffer.from(value);
+    return bytes.byteLength <= maximum ? value : bytes.subarray(0, maximum).toString();
+}

package/dist/runtime/scheduler.d.ts

@@ -0,0 +1,15 @@
+import { type ResourceClaim } from './capabilities.js';
+export interface SchedulerLimits {
+    readonly instanceMax: number;
+    readonly perStepMax: number;
+    readonly perAdapterMax: number;
+}
+export declare class Scheduler {
+    #private;
+    constructor(limits: SchedulerLimits);
+    updateLimits(limits: SchedulerLimits): void;
+    acquire(callId: string, adapterId: string, stepId: string | null, claims: readonly ResourceClaim[], start: () => void, signal?: AbortSignal): Promise<AbortSignal>;
+    release(callId: string): void;
+    cancel(callId: string): boolean;
+    close(): void;
+}

package/dist/runtime/scheduler.js

@@ -0,0 +1,85 @@
+import { claimsConflict } from './capabilities.js';
+export class Scheduler {
+    #leases = new Map();
+    #waiters = new Set();
+    #limits;
+    #closed = false;
+    constructor(limits) {
+        this.#limits = limits;
+    }
+    updateLimits(limits) {
+        this.#limits = limits;
+        this.#wake();
+    }
+    async acquire(callId, adapterId, stepId, claims, start, signal) {
+        while (!this.#closed) {
+            const controller = this.#tryAcquire(callId, adapterId, stepId, claims);
+            if (controller !== null) {
+                try {
+                    start();
+                }
+                catch (error) {
+                    this.#leases.delete(callId);
+                    this.#wake();
+                    throw error;
+                }
+                signal?.addEventListener('abort', () => controller.abort(signal.reason), { once: true });
+                return controller.signal;
+            }
+            await new Promise((resolve) => {
+                const wake = () => {
+                    signal?.removeEventListener('abort', wake);
+                    this.#waiters.delete(wake);
+                    resolve();
+                };
+                this.#waiters.add(wake);
+                signal?.addEventListener('abort', wake, { once: true });
+            });
+            if (signal?.aborted === true)
+                throw signal.reason;
+        }
+        throw new Error('Scheduler is closed.');
+    }
+    release(callId) {
+        if (!this.#leases.delete(callId))
+            return;
+        this.#wake();
+    }
+    cancel(callId) {
+        const lease = this.#leases.get(callId);
+        if (lease === undefined)
+            return false;
+        lease.controller.abort(new Error('Call cancelled.'));
+        return true;
+    }
+    close() {
+        this.#closed = true;
+        for (const lease of this.#leases.values())
+            lease.controller.abort(new Error('Scheduler closed.'));
+        this.#wake();
+    }
+    #tryAcquire(callId, adapterId, stepId, claims) {
+        if (this.#leases.has(callId) || this.#leases.size >= this.#limits.instanceMax)
+            return null;
+        let adapterCount = 0;
+        let stepCount = 0;
+        for (const lease of this.#leases.values()) {
+            if (lease.adapterId === adapterId)
+                adapterCount += 1;
+            if (stepId !== null && lease.stepId === stepId)
+                stepCount += 1;
+            if (claimsConflict(lease.claims, claims))
+                return null;
+        }
+        if (adapterCount >= this.#limits.perAdapterMax || stepCount >= this.#limits.perStepMax)
+            return null;
+        const controller = new AbortController();
+        this.#leases.set(callId, { callId, adapterId, stepId, claims, controller });
+        return controller;
+    }
+    #wake() {
+        for (const wake of this.#waiters)
+            wake();
+        this.#waiters.clear();
+    }
+}

package/dist/runtime/skills.d.ts

@@ -0,0 +1,2 @@
+import type { RegisteredCapability } from './capabilities.js';
+export declare function workspaceSkills(workspacePaths: readonly string[]): readonly RegisteredCapability[];

package/dist/runtime/skills.js

@@ -0,0 +1,83 @@
+import { lstatSync, readFileSync, readdirSync, realpathSync } from 'node:fs';
+import { relative, resolve, sep } from 'node:path';
+import { createHash } from 'node:crypto';
+import { capabilityManifest } from './manifests.js';
+const roots = ['skills', '.agents/skills', '.codex/skills'];
+export function workspaceSkills(workspacePaths) {
+    const selected = new Map();
+    for (const workspacePath of workspacePaths) {
+        const workspace = realpathSync(resolve(workspacePath));
+        for (const rootName of roots) {
+            const root = resolve(workspace, rootName);
+            if (!directory(root))
+                continue;
+            for (const entry of readdirSync(root, { withFileTypes: true }).filter((item) => item.isDirectory()).sort((a, b) => a.name.localeCompare(b.name))) {
+                const source = resolve(root, entry.name, 'SKILL.md');
+                if (!file(source))
+                    continue;
+                const canonical = realpathSync(source);
+                if (!inside(workspace, canonical))
+                    continue;
+                const name = entry.name.replace(/[^A-Za-z0-9._-]/g, '-').replace(/^-+|-+$/g, '');
+                if (name.length === 0)
+                    continue;
+                const id = `skill:${name}`;
+                if (selected.has(id))
+                    continue;
+                const content = readFileSync(canonical, 'utf8').trim();
+                const title = /^#\s+(.+)$/m.exec(content)?.[1]?.trim() ?? name;
+                const promptText = [
+                    `Skill: ${title}`,
+                    `Source: ${relative(workspace, canonical).replaceAll(sep, '/')}`,
+                    `Content-Digest: ${createHash('sha256').update(content).digest('hex')}`,
+                    '',
+                    content
+                ].join('\n');
+                const adapter = {
+                    id: `skill.${name}`,
+                    execute: () => Promise.resolve({ content: { instructions: promptText } })
+                };
+                const definition = {
+                    id,
+                    title,
+                    description: `Load the ${title} instructions from this Workspace.`,
+                    inputSchema: { type: 'object', additionalProperties: false },
+                    effect: 'read_only',
+                    adapterId: adapter.id,
+                    loadMode: 'deferred',
+                    outputLimitBytes: 262144,
+                    defaultAssignment: 'all_new_agents',
+                    kind: 'skill',
+                    promptText
+                };
+                selected.set(id, {
+                    definition,
+                    adapter,
+                    manifest: capabilityManifest(definition),
+                    claims: () => []
+                });
+            }
+        }
+    }
+    return [...selected.values()].sort((left, right) => left.definition.id.localeCompare(right.definition.id));
+}
+function directory(path) {
+    try {
+        return lstatSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function file(path) {
+    try {
+        return lstatSync(path).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function inside(root, candidate) {
+    const relation = relative(root, candidate);
+    return relation === '' || relation !== '..' && !relation.startsWith(`..${sep}`);
+}

package/dist/runtime/tokenizer.d.ts

@@ -0,0 +1,8 @@
+export interface TokenEstimate {
+    readonly expected: number;
+    readonly safe: number;
+    readonly estimated: true;
+    readonly version: 1;
+}
+export declare function estimateTokens(value: string): TokenEstimate;
+export declare function estimateRequest(value: unknown): TokenEstimate;

package/dist/runtime/tokenizer.js

@@ -0,0 +1,30 @@
+export function estimateTokens(value) {
+    let units = 0;
+    let asciiRun = 0;
+    const flush = () => {
+        units += Math.ceil(asciiRun / 4);
+        asciiRun = 0;
+    };
+    for (const character of value) {
+        const code = character.codePointAt(0) ?? 0;
+        if (code <= 0x7f && /[a-zA-Z0-9_]/.test(character)) {
+            asciiRun += 1;
+            continue;
+        }
+        flush();
+        if (/\s/u.test(character))
+            continue;
+        if (code >= 0x4e00 && code <= 0x9fff)
+            units += 1;
+        else if (code > 0xffff)
+            units += 2;
+        else
+            units += 1;
+    }
+    flush();
+    const expected = Math.max(1, units);
+    return { expected, safe: Math.ceil(expected * 1.25) + 8, estimated: true, version: 1 };
+}
+export function estimateRequest(value) {
+    return estimateTokens(JSON.stringify(value));
+}

package/dist/store/database.d.ts

@@ -0,0 +1,3 @@
+import Database from 'better-sqlite3';
+export type Sqlite = Database.Database;
+export declare function openDatabase(root: string, file: string): Sqlite;

package/dist/store/database.js

@@ -0,0 +1,49 @@
+import { mkdirSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import Database from 'better-sqlite3';
+import { id, now } from '../core/codec.js';
+import { fail } from '../core/domain.js';
+import { schema } from './schema.js';
+/**
+ * Columns added after a database already existed.
+ *
+ * `schema.ts` is one idempotent script, which works for `CREATE TABLE IF NOT EXISTS` and not for a new
+ * column: SQLite has no `ADD COLUMN IF NOT EXISTS`, so a second start would fail on a duplicate. The
+ * alternative was `storage:rebuild`, which discards every Task and Run to add a nullable text column.
+ *
+ * Each entry has to stay safe to re-run for the life of the file, so this reads the current columns
+ * rather than tracking a version. Keep it small: it is a way to add a nullable column, not a migration
+ * framework.
+ */
+const ADDED_COLUMNS = [
+    // Why a Run failed, not just that it did. `error_code` alone made every Provider rejection, TLS fault
+    // and malformed Tool block read as one indistinguishable `RUNTIME_FAILED`, and `RunDetail.error.message`
+    // could only repeat the code back.
+    { table: 'runs', column: 'error_message', definition: 'TEXT' },
+    { table: 'steps', column: 'error_message', definition: 'TEXT' }
+];
+function addColumns(database) {
+    for (const { table, column, definition } of ADDED_COLUMNS) {
+        const columns = database.prepare(`PRAGMA table_info(${table})`).all();
+        if (columns.some((entry) => entry.name === column))
+            continue;
+        database.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
+    }
+}
+export function openDatabase(root, file) {
+    const path = resolve(root, file);
+    mkdirSync(dirname(path), { recursive: true });
+    try {
+        const database = new Database(path);
+        database.exec(schema);
+        addColumns(database);
+        database.prepare('INSERT OR IGNORE INTO instance(id, epoch, state_revision, created_at) VALUES (1, ?, 0, ?)')
+            .run(id('instance'), now());
+        return database;
+    }
+    catch (error) {
+        fail('DATABASE_UNAVAILABLE', 503, 'The database could not be opened.', {
+            reason: error instanceof Error ? error.message : String(error)
+        });
+    }
+}

package/dist/store/event-log.d.ts

@@ -0,0 +1,19 @@
+import { type Json } from '../core/domain.js';
+interface EventRecord {
+    readonly revision: number;
+    readonly occurred_at: string;
+    readonly previous_hash: string | null;
+    readonly state: Json;
+    readonly hash: string;
+}
+export declare class EventLog {
+    #private;
+    readonly fsync: boolean;
+    readonly path: string;
+    constructor(root: string, path: string, fsync: boolean);
+    load(): Promise<void>;
+    append(revision: number, state: Json): void;
+    close(): Promise<void>;
+}
+export declare function readEventLog(path: string): Promise<readonly EventRecord[]>;
+export {};

package/dist/store/event-log.js

@@ -0,0 +1,61 @@
+import { createHash } from 'node:crypto';
+import { appendFile, mkdir, open, readFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { canonicalize } from 'json-canonicalize';
+import { now } from '../core/codec.js';
+import { fail } from '../core/domain.js';
+export class EventLog {
+    fsync;
+    path;
+    #tail = Promise.resolve();
+    #hash = null;
+    constructor(root, path, fsync) {
+        this.fsync = fsync;
+        this.path = resolve(root, path);
+    }
+    async load() {
+        const records = await readEventLog(this.path).catch((error) => {
+            if (isMissing(error))
+                return [];
+            throw error;
+        });
+        this.#hash = records.at(-1)?.hash ?? null;
+    }
+    append(revision, state) {
+        this.#tail = this.#tail.then(async () => {
+            const base = { revision, occurred_at: now(), previous_hash: this.#hash, state };
+            const record = { ...base, hash: hash(base) };
+            await mkdir(dirname(this.path), { recursive: true });
+            await appendFile(this.path, `${JSON.stringify(record)}\n`, 'utf8');
+            if (this.fsync) {
+                const file = await open(this.path, 'r');
+                await file.sync();
+                await file.close();
+            }
+            this.#hash = record.hash;
+        });
+    }
+    close() {
+        return this.#tail;
+    }
+}
+export async function readEventLog(path) {
+    const source = await readFile(path, 'utf8');
+    const records = [];
+    let previous = null;
+    for (const line of source.split(/\r?\n/).filter(Boolean)) {
+        const value = JSON.parse(line);
+        const base = { revision: value.revision, occurred_at: value.occurred_at, previous_hash: value.previous_hash, state: value.state };
+        if (value.previous_hash !== previous || value.hash !== hash(base))
+            fail('EVENT_LOG_INVALID', 503, 'The Event Log hash chain is invalid.');
+        records.push(value);
+        previous = value.hash;
+    }
+    return records;
+}
+function hash(value) {
+    return createHash('sha256').update(canonicalize(value)).digest('hex');
+}
+function isMissing(error) {
+    return typeof error === 'object' && error !== null && 'code' in error && error.code === 'ENOENT';
+}

package/dist/store/schema.d.ts

@@ -0,0 +1 @@
+export declare const schema = "\nPRAGMA foreign_keys = ON;\nPRAGMA journal_mode = WAL;\nPRAGMA synchronous = NORMAL;\nPRAGMA busy_timeout = 5000;\n\nCREATE TABLE IF NOT EXISTS instance (\n  id INTEGER PRIMARY KEY CHECK (id = 1),\n  epoch TEXT NOT NULL,\n  state_revision INTEGER NOT NULL CHECK (state_revision >= 0),\n  created_at TEXT NOT NULL\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS projects (\n  id TEXT PRIMARY KEY,\n  name TEXT NOT NULL UNIQUE,\n  archived_at TEXT,\n  revision INTEGER NOT NULL CHECK (revision >= 0),\n  created_at TEXT NOT NULL,\n  updated_at TEXT NOT NULL\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS workspaces (\n  id TEXT PRIMARY KEY,\n  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,\n  name TEXT NOT NULL,\n  is_default INTEGER NOT NULL CHECK (is_default IN (0, 1)),\n  revision INTEGER NOT NULL CHECK (revision >= 0),\n  created_at TEXT NOT NULL,\n  updated_at TEXT NOT NULL,\n  UNIQUE(project_id, name)\n) STRICT;\nCREATE UNIQUE INDEX IF NOT EXISTS workspace_default ON workspaces(project_id) WHERE is_default = 1;\n\nCREATE TABLE IF NOT EXISTS workspace_paths (\n  workspace_id TEXT NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,\n  ordinal INTEGER NOT NULL CHECK (ordinal >= 0),\n  path TEXT NOT NULL,\n  PRIMARY KEY(workspace_id, ordinal),\n  UNIQUE(workspace_id, path)\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS tasks (\n  id TEXT PRIMARY KEY,\n  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,\n  title TEXT NOT NULL,\n  archived_at TEXT,\n  revision INTEGER NOT NULL CHECK (revision >= 0),\n  created_at TEXT NOT NULL,\n  updated_at TEXT NOT NULL\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS sessions (\n  id TEXT PRIMARY KEY,\n  task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,\n  title TEXT NOT NULL,\n  archived_at TEXT,\n  revision INTEGER NOT NULL CHECK (revision >= 0),\n  created_at TEXT NOT NULL,\n  updated_at TEXT NOT NULL\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS agents (\n  id TEXT PRIMARY KEY,\n  task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,\n  session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,\n  workspace_id TEXT NOT NULL REFERENCES workspaces(id) ON DELETE RESTRICT,\n  parent_agent_id TEXT REFERENCES agents(id) ON DELETE SET NULL,\n  name TEXT NOT NULL,\n  state TEXT NOT NULL CHECK (state IN ('IDLE', 'RUNNING', 'WAITING', 'STOPPED')),\n  model TEXT NOT NULL,\n  model_reasoning_effort TEXT NOT NULL,\n  policy_preset TEXT NOT NULL,\n  context_revision INTEGER NOT NULL CHECK (context_revision >= 0),\n  revision INTEGER NOT NULL CHECK (revision >= 0),\n  created_at TEXT NOT NULL,\n  updated_at TEXT NOT NULL\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS messages (\n  id TEXT PRIMARY KEY,\n  agent_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,\n  source_agent_id TEXT REFERENCES agents(id) ON DELETE SET NULL,\n  role TEXT NOT NULL CHECK (role IN ('system', 'user', 'assistant', 'tool')),\n  content TEXT NOT NULL,\n  metadata_json TEXT,\n  created_at TEXT NOT NULL\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS pending_messages (\n  id TEXT PRIMARY KEY,\n  agent_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,\n  message_id TEXT NOT NULL REFERENCES messages(id) ON DELETE CASCADE,\n  source_agent_id TEXT REFERENCES agents(id) ON DELETE SET NULL,\n  content TEXT NOT NULL,\n  ordinal INTEGER NOT NULL CHECK (ordinal >= 0),\n  revision INTEGER NOT NULL CHECK (revision >= 0),\n  created_at TEXT NOT NULL,\n  updated_at TEXT NOT NULL,\n  UNIQUE(agent_id, ordinal)\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS runs (\n  id TEXT PRIMARY KEY,\n  agent_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,\n  goal_message_ids_json TEXT NOT NULL DEFAULT '[]',\n  initial_step_pending INTEGER NOT NULL DEFAULT 0 CHECK (initial_step_pending IN (0, 1)),\n  state TEXT NOT NULL CHECK (state IN ('READY', 'RUNNING', 'WAITING', 'TERMINAL')),\n  outcome TEXT CHECK (outcome IN ('success', 'failed', 'cancelled', 'interrupted')),\n  error_code TEXT,\n  revision INTEGER NOT NULL CHECK (revision >= 0),\n  created_at TEXT NOT NULL,\n  updated_at TEXT NOT NULL\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS steps (\n  id TEXT PRIMARY KEY,\n  run_id TEXT NOT NULL REFERENCES runs(id) ON DELETE CASCADE,\n  turn_group_id TEXT NOT NULL REFERENCES context_turn_groups(id) ON DELETE RESTRICT,\n  ordinal INTEGER NOT NULL CHECK (ordinal >= 0),\n  state TEXT NOT NULL CHECK (state IN ('RUNNING', 'WAITING', 'TERMINAL')),\n  outcome TEXT CHECK (outcome IN ('success', 'failed', 'cancelled', 'interrupted')),\n  error_code TEXT,\n  created_at TEXT NOT NULL,\n  updated_at TEXT NOT NULL,\n  UNIQUE(run_id, ordinal)\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS model_attempts (\n  id TEXT PRIMARY KEY,\n  agent_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,\n  step_id TEXT REFERENCES steps(id) ON DELETE CASCADE,\n  kind TEXT NOT NULL CHECK (kind IN ('agent', 'compaction')),\n  sequence INTEGER NOT NULL CHECK (sequence >= 0),\n  model TEXT NOT NULL,\n  state TEXT NOT NULL CHECK (state IN ('PREPARED', 'RUNNING', 'TERMINAL')),\n  outcome TEXT CHECK (outcome IN ('success', 'failed', 'cancelled', 'interrupted')),\n  profile_id TEXT NOT NULL,\n  profile_version INTEGER NOT NULL CHECK (profile_version >= 1),\n  profile_digest TEXT NOT NULL,\n  config_digest TEXT NOT NULL,\n  context_revision INTEGER NOT NULL CHECK (context_revision >= 0),\n  request_digest TEXT NOT NULL,\n  preparation_json TEXT NOT NULL,\n  usage_json TEXT,\n  error_code TEXT,\n  created_at TEXT NOT NULL,\n  updated_at TEXT NOT NULL,\n  UNIQUE(agent_id, kind, sequence)\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS attempt_capabilities (\n  attempt_id TEXT NOT NULL REFERENCES model_attempts(id) ON DELETE CASCADE,\n  ordinal INTEGER NOT NULL CHECK (ordinal >= 0),\n  capability_id TEXT NOT NULL,\n  schema_json TEXT NOT NULL,\n  PRIMARY KEY(attempt_id, ordinal),\n  UNIQUE(attempt_id, capability_id)\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS attempt_tool_ordinals (\n  attempt_id TEXT NOT NULL REFERENCES model_attempts(id) ON DELETE CASCADE,\n  ordinal INTEGER NOT NULL CHECK (ordinal >= 0),\n  provider_tool_id TEXT,\n  complete INTEGER NOT NULL CHECK (complete IN (0, 1)),\n  PRIMARY KEY(attempt_id, ordinal)\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS call_partitions (\n  id TEXT PRIMARY KEY,\n  step_id TEXT NOT NULL REFERENCES steps(id) ON DELETE CASCADE,\n  ordinal INTEGER NOT NULL CHECK (ordinal >= 0),\n  mode TEXT NOT NULL CHECK (mode IN ('parallel', 'serial')),\n  created_at TEXT NOT NULL,\n  UNIQUE(step_id, ordinal)\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS calls (\n  id TEXT PRIMARY KEY,\n  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,\n  workspace_id TEXT NOT NULL REFERENCES workspaces(id) ON DELETE RESTRICT,\n  agent_id TEXT REFERENCES agents(id) ON DELETE SET NULL,\n  step_id TEXT REFERENCES steps(id) ON DELETE CASCADE,\n  attempt_id TEXT REFERENCES model_attempts(id) ON DELETE CASCADE,\n  partition_id TEXT REFERENCES call_partitions(id) ON DELETE CASCADE,\n  parent_call_id TEXT REFERENCES calls(id) ON DELETE CASCADE,\n  source TEXT NOT NULL CHECK (source IN ('user', 'llm', 'program')),\n  capability_id TEXT NOT NULL,\n  provider_call_id TEXT,\n  call_ordinal INTEGER CHECK (call_ordinal >= 0),\n  input_json TEXT NOT NULL,\n  effect TEXT NOT NULL CHECK (effect IN ('read_only', 'workspace_write', 'external', 'full')),\n  policy TEXT CHECK (policy IN ('read_only', 'workspace_write', 'external', 'ask', 'auto_approve', 'full_access')),\n  state TEXT NOT NULL CHECK (state IN ('WAITING', 'QUEUED', 'RUNNING', 'TERMINAL')),\n  wait_reason TEXT CHECK (wait_reason IN ('user_input', 'policy_review')),\n  outcome TEXT CHECK (outcome IN ('success', 'failed', 'cancelled', 'interrupted')),\n  outcome_unknown INTEGER NOT NULL CHECK (outcome_unknown IN (0, 1)),\n  auto_review_passed INTEGER CHECK (auto_review_passed IN (0, 1)),\n  revision INTEGER NOT NULL CHECK (revision >= 0),\n  created_at TEXT NOT NULL,\n  updated_at TEXT NOT NULL,\n  UNIQUE(attempt_id, call_ordinal)\n) STRICT;\nCREATE UNIQUE INDEX IF NOT EXISTS calls_by_provider_call ON calls(attempt_id, provider_call_id) WHERE provider_call_id IS NOT NULL;\n\nCREATE TABLE IF NOT EXISTS results (\n  id TEXT PRIMARY KEY,\n  call_id TEXT NOT NULL UNIQUE REFERENCES calls(id) ON DELETE CASCADE,\n  outcome TEXT NOT NULL CHECK (outcome IN ('success', 'failed', 'cancelled', 'interrupted')),\n  content_json TEXT NOT NULL,\n  truncated INTEGER NOT NULL DEFAULT 0 CHECK (truncated IN (0, 1)),\n  error_code TEXT,\n  error_message TEXT,\n  created_at TEXT NOT NULL\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS artifacts (\n  id TEXT PRIMARY KEY,\n  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,\n  name TEXT NOT NULL,\n  media_type TEXT NOT NULL,\n  relative_path TEXT NOT NULL,\n  sha256 TEXT NOT NULL,\n  size_bytes INTEGER NOT NULL CHECK (size_bytes >= 0),\n  created_at TEXT NOT NULL\n) STRICT;\nCREATE UNIQUE INDEX IF NOT EXISTS artifact_identity ON artifacts(project_id, sha256, name, media_type);\nCREATE INDEX IF NOT EXISTS artifacts_by_path ON artifacts(relative_path);\n\nCREATE TABLE IF NOT EXISTS result_artifacts (\n  result_id TEXT NOT NULL REFERENCES results(id) ON DELETE CASCADE,\n  artifact_id TEXT NOT NULL REFERENCES artifacts(id) ON DELETE RESTRICT,\n  PRIMARY KEY(result_id, artifact_id)\n) STRICT;\n\n-- No table for write_file/edit_file file history: it belongs to the Executor, which owns the files\n-- and therefore the only authoritative view of what they contained. Core keeps Call semantics and\n-- asks the Executor to revert by call_id. See\n-- docs/architecture/harness-level3/09-file-snapshot-storage-decision.md.\n\nCREATE TABLE IF NOT EXISTS context_turn_groups (\n  id TEXT PRIMARY KEY,\n  agent_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,\n  ordinal INTEGER NOT NULL CHECK (ordinal >= 0),\n  kind TEXT NOT NULL CHECK (kind IN ('turn', 'compaction', 'included', 'ledger')),\n  state TEXT NOT NULL CHECK (state IN ('OPEN', 'COMPLETE', 'ABORTED')),\n  revision INTEGER NOT NULL CHECK (revision >= 0),\n  created_at TEXT NOT NULL,\n  completed_at TEXT,\n  UNIQUE(agent_id, ordinal)\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS context_items (\n  id TEXT PRIMARY KEY,\n  agent_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,\n  turn_group_id TEXT NOT NULL REFERENCES context_turn_groups(id) ON DELETE CASCADE,\n  turn_group_ordinal INTEGER NOT NULL CHECK (turn_group_ordinal >= 0),\n  kind TEXT NOT NULL CHECK (kind IN ('message', 'tool_calls', 'result', 'compaction')),\n  source_id TEXT NOT NULL,\n  role TEXT CHECK (role IN ('system', 'user', 'assistant', 'tool')),\n  content TEXT NOT NULL,\n  tool_call_id TEXT,\n  tool_name TEXT,\n  ordinal INTEGER NOT NULL CHECK (ordinal >= 0),\n  visible INTEGER NOT NULL CHECK (visible IN (0, 1)),\n  locked INTEGER NOT NULL CHECK (locked IN (0, 1)),\n  revision INTEGER NOT NULL CHECK (revision >= 0),\n  created_at TEXT NOT NULL,\n  updated_at TEXT NOT NULL,\n  UNIQUE(agent_id, ordinal),\n  UNIQUE(turn_group_id, turn_group_ordinal)\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS context_overrides (\n  id TEXT PRIMARY KEY,\n  agent_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,\n  target_kind TEXT NOT NULL CHECK (target_kind IN ('agent', 'message', 'result', 'artifact')),\n  target_id TEXT NOT NULL,\n  instructions TEXT NOT NULL,\n  revision INTEGER NOT NULL CHECK (revision >= 0),\n  created_at TEXT NOT NULL,\n  updated_at TEXT NOT NULL,\n  UNIQUE(agent_id, target_kind, target_id)\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS projection_decisions (\n  id TEXT PRIMARY KEY,\n  agent_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,\n  attempt_id TEXT REFERENCES model_attempts(id) ON DELETE CASCADE,\n  stage TEXT NOT NULL,\n  source_tokens INTEGER NOT NULL CHECK (source_tokens >= 0),\n  projected_tokens INTEGER NOT NULL CHECK (projected_tokens >= 0),\n  details_json TEXT NOT NULL,\n  created_at TEXT NOT NULL\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS capability_assignments (\n  agent_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,\n  capability_id TEXT NOT NULL,\n  policy TEXT NOT NULL CHECK (policy IN ('read_only', 'workspace_write', 'external', 'ask', 'auto_approve', 'full_access')),\n  assigned_at TEXT NOT NULL,\n  PRIMARY KEY(agent_id, capability_id)\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS capability_loads (\n  agent_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,\n  capability_id TEXT NOT NULL,\n  loaded_at TEXT NOT NULL,\n  PRIMARY KEY(agent_id, capability_id),\n  FOREIGN KEY(agent_id, capability_id) REFERENCES capability_assignments(agent_id, capability_id) ON DELETE CASCADE\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS agent_plans (\n  agent_id TEXT PRIMARY KEY REFERENCES agents(id) ON DELETE CASCADE,\n  items_json TEXT NOT NULL,\n  revision INTEGER NOT NULL CHECK (revision >= 0),\n  updated_at TEXT NOT NULL\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS ingress_requests (\n  client_id TEXT NOT NULL,\n  key TEXT NOT NULL,\n  operation TEXT NOT NULL,\n  request_digest TEXT NOT NULL,\n  response_json TEXT NOT NULL,\n  created_at TEXT NOT NULL,\n  PRIMARY KEY(client_id, key)\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS side_effect_ledgers (\n  id TEXT PRIMARY KEY,\n  step_id TEXT NOT NULL REFERENCES steps(id) ON DELETE CASCADE,\n  content TEXT NOT NULL,\n  created_at TEXT NOT NULL\n) STRICT;\n\nCREATE INDEX IF NOT EXISTS tasks_by_project ON tasks(project_id, archived_at, updated_at DESC);\nCREATE INDEX IF NOT EXISTS sessions_by_task ON sessions(task_id, archived_at, updated_at DESC);\nCREATE INDEX IF NOT EXISTS agents_by_session ON agents(session_id, parent_agent_id, created_at);\nCREATE INDEX IF NOT EXISTS pending_by_agent ON pending_messages(agent_id, ordinal);\nCREATE INDEX IF NOT EXISTS runs_by_agent ON runs(agent_id, created_at DESC);\nCREATE UNIQUE INDEX IF NOT EXISTS one_live_run_per_agent ON runs(agent_id) WHERE state != 'TERMINAL';\nCREATE INDEX IF NOT EXISTS attempts_by_step ON model_attempts(step_id, sequence);\nCREATE INDEX IF NOT EXISTS calls_by_project ON calls(project_id, state, created_at DESC);\nCREATE INDEX IF NOT EXISTS context_by_agent ON context_items(agent_id, ordinal);\nCREATE INDEX IF NOT EXISTS artifacts_by_project ON artifacts(project_id, created_at DESC);\n";