praxis-agent 0.36.0 → 0.37.0

package/dist/persistence/native-team-store.js

@@ -0,0 +1,257 @@
+import { readFile, readdir } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { parseTeamId, parseTeamSnapshot, } from '../core/team-ownership.js';
+import { writeFileAtomically } from '../platform/atomic-write.js';
+import { ExclusiveFileLease, } from '../platform/exclusive-file-lease.js';
+import { resolveProjectIdentity } from '../platform/project-identity.js';
+import { sanitizeProjectPath } from '../platform/project-path-key.js';
+function assertTeamId(teamId) {
+    parseTeamId(teamId);
+}
+function assertRoot(root) {
+    if (typeof root !== 'string' || root.trim() === '')
+        throw new Error('Invalid native Team root');
+    return resolve(root);
+}
+export class NativeTeamStore {
+    nativeRoot;
+    projectIdentity;
+    projectRoot;
+    mutation = Promise.resolve();
+    constructor(nativeRoot, projectIdentity) {
+        this.nativeRoot = nativeRoot;
+        this.projectIdentity = projectIdentity;
+        this.projectRoot = resolve(nativeRoot, 'state', 'teams', sanitizeProjectPath(projectIdentity));
+    }
+    static async open(options) {
+        const root = assertRoot(options.nativeRoot);
+        const projectIdentity = await resolveProjectIdentity(options.cwd);
+        return new NativeTeamStore(root, projectIdentity);
+    }
+    async createAndClaim(snapshot) {
+        const parsed = parseTeamSnapshot(snapshot);
+        this.assertSnapshot(parsed, parsed.teamId);
+        if (parsed.revision !== 0)
+            throw new Error('Native Team creation requires revision 0');
+        const claim = await this.acquireClaim(parsed.teamId);
+        let mutation;
+        try {
+            mutation = await this.acquireMutation(parsed.teamId);
+            if (await this.exists(this.statePath(parsed.teamId)))
+                throw new Error(`Native Team state already exists: ${this.statePath(parsed.teamId)}`);
+            await writeFileAtomically(this.statePath(parsed.teamId), `${JSON.stringify(parsed)}\n`, { mode: 0o600 });
+            return claim;
+        }
+        catch (error) {
+            await claim.release();
+            throw error;
+        }
+        finally {
+            await mutation?.release();
+        }
+    }
+    async claim(teamId) {
+        assertTeamId(teamId);
+        const claim = await this.acquireClaim(teamId);
+        try {
+            const snapshot = await this.read(teamId);
+            if (snapshot === null)
+                throw new Error(`Missing native Team state: ${this.statePath(teamId)}`);
+            return claim;
+        }
+        catch (error) {
+            await claim.release();
+            throw error;
+        }
+    }
+    async read(teamId) {
+        assertTeamId(teamId);
+        const path = this.statePath(teamId);
+        let source;
+        try {
+            source = await readFile(path, 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return null;
+            throw error;
+        }
+        let value;
+        try {
+            value = JSON.parse(source);
+        }
+        catch (error) {
+            throw new Error(`Corrupt native Team state: ${path}`, { cause: error });
+        }
+        let snapshot;
+        try {
+            snapshot = parseTeamSnapshot(value);
+            this.assertSnapshot(snapshot, teamId);
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                error.message.startsWith('Invalid native Team state:'))
+                throw error;
+            throw new Error(`Invalid native Team state: ${path}`, { cause: error });
+        }
+        return snapshot;
+    }
+    async list() {
+        let entries;
+        try {
+            entries = await readdir(this.projectRoot, { withFileTypes: true });
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return [];
+            throw error;
+        }
+        const ids = entries
+            .filter((entry) => {
+            if (!entry.isDirectory())
+                return false;
+            try {
+                parseTeamId(entry.name);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        })
+            .map((entry) => entry.name)
+            .sort();
+        const snapshots = [];
+        for (const id of ids) {
+            const snapshot = await this.read(id);
+            if (snapshot === null)
+                throw new Error(`Invalid native Team state: ${this.statePath(id)}`);
+            snapshots.push(snapshot);
+        }
+        return Object.freeze(snapshots);
+    }
+    async acquireClaim(teamId) {
+        assertTeamId(teamId);
+        const lease = await new ExclusiveFileLease(`${this.statePath(teamId)}.owner.lock`).tryAcquire();
+        if (!lease)
+            throw new Error(`Team ${teamId} is already owned`);
+        return new NativeTeamClaimImpl(teamId, lease, async () => {
+            const snapshot = await this.read(teamId);
+            if (snapshot === null)
+                throw new Error(`Missing native Team state: ${this.statePath(teamId)}`);
+            return snapshot;
+        }, (expectedRevision, next) => this.save(teamId, expectedRevision, next));
+    }
+    async acquireMutation(teamId) {
+        const leaseFile = `${this.statePath(teamId)}.mutation.lock`;
+        const deadline = Date.now() + 5_000;
+        for (;;) {
+            const lease = await new ExclusiveFileLease(leaseFile).tryAcquire();
+            if (lease)
+                return lease;
+            if (Date.now() >= deadline)
+                throw new Error(`Team ${teamId} mutation is busy: ${this.statePath(teamId)}`);
+            await new Promise((resolveDelay) => setTimeout(resolveDelay, 10));
+        }
+    }
+    enqueue(operation) {
+        const queued = this.mutation.then(operation);
+        this.mutation = queued.then(() => undefined, () => undefined);
+        return queued;
+    }
+    async save(teamId, expectedRevision, next) {
+        if (!Number.isSafeInteger(expectedRevision) || expectedRevision < 0)
+            throw new Error('Invalid expected Team revision');
+        return this.enqueue(async () => {
+            const mutation = await this.acquireMutation(teamId);
+            try {
+                const current = await this.read(teamId);
+                if (current === null)
+                    throw new Error(`Missing native Team state: ${this.statePath(teamId)}`);
+                if (current.revision !== expectedRevision)
+                    throw new Error(`Team revision conflict: expected ${expectedRevision}, found ${current.revision}`);
+                const parsed = parseTeamSnapshot(next);
+                this.assertSnapshot(parsed, teamId);
+                if (parsed.teamId !== current.teamId ||
+                    parsed.projectIdentity !== current.projectIdentity ||
+                    parsed.leadSessionId !== current.leadSessionId ||
+                    parsed.createdAt !== current.createdAt)
+                    throw new Error('Immutable native Team identity fields changed');
+                if (JSON.stringify(parsed.policy) !== JSON.stringify(current.policy) ||
+                    JSON.stringify(parsed.budgets) !== JSON.stringify(current.budgets))
+                    throw new Error('Immutable native Team policy or budgets changed');
+                if (parsed.revision !== current.revision + 1 ||
+                    parsed.updatedAt < current.updatedAt)
+                    throw new Error('Invalid native Team revision or timestamp');
+                await writeFileAtomically(this.statePath(teamId), `${JSON.stringify(parsed)}\n`, { mode: 0o600 });
+                return parsed;
+            }
+            finally {
+                await mutation.release();
+            }
+        });
+    }
+    assertSnapshot(snapshot, teamId) {
+        if (snapshot.projectIdentity !== this.projectIdentity ||
+            snapshot.teamId !== teamId)
+            throw new Error(`Invalid native Team state: ${this.statePath(teamId)}`);
+    }
+    statePath(teamId) {
+        return resolve(this.projectRoot, teamId, 'team.json');
+    }
+    async exists(path) {
+        try {
+            await readFile(path);
+            return true;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return false;
+            throw error;
+        }
+    }
+}
+class NativeTeamClaimImpl {
+    lease;
+    readState;
+    saveState;
+    active = true;
+    operations = Promise.resolve();
+    releasePromise;
+    teamId;
+    token;
+    pid;
+    acquiredAt;
+    constructor(teamId, lease, readState, saveState) {
+        this.lease = lease;
+        this.readState = readState;
+        this.saveState = saveState;
+        this.teamId = teamId;
+        this.token = lease.token;
+        this.pid = lease.pid;
+        this.acquiredAt = lease.createdAt;
+    }
+    assertActive() {
+        if (!this.active)
+            throw new Error(`Team ${this.teamId} claim is released`);
+    }
+    read() {
+        return this.admit(() => this.readState());
+    }
+    save(expectedRevision, next) {
+        return this.admit(() => this.saveState(expectedRevision, next));
+    }
+    async release() {
+        if (this.releasePromise)
+            return this.releasePromise;
+        this.active = false;
+        this.releasePromise = this.operations.then(() => this.lease.release());
+        return this.releasePromise;
+    }
+    admit(operation) {
+        this.assertActive();
+        const admitted = this.operations.then(operation, operation);
+        this.operations = admitted.then(() => undefined, () => undefined);
+        return admitted;
+    }
+}
+//# sourceMappingURL=native-team-store.js.map

package/dist/persistence/native-transcript-store.d.ts

@@ -0,0 +1,69 @@
+import type { TranscriptEvent } from '../core/transcript-event.js';
+import { type DecodedTranscriptRecord, type TranscriptCodecDiagnostic } from '../core/transcript-codec.js';
+export interface NativeTranscriptTail {
+    byteLength: number;
+    lastLineHash: string | null;
+    lastEventId: string | null;
+    newlineTerminated: boolean;
+    branchParentId?: string | null;
+}
+export interface NativeTranscriptSnapshot {
+    records: readonly DecodedTranscriptRecord[];
+    tail: NativeTranscriptTail;
+}
+export interface NativeTranscriptRecovery extends NativeTranscriptSnapshot {
+    issue: TranscriptCodecDiagnostic | null;
+}
+export type NativeTranscriptAppendResult = {
+    status: 'appended';
+    tail: NativeTranscriptTail;
+} | {
+    status: 'conflict';
+    reason: 'interleaved-write' | 'locked' | 'tail-changed';
+};
+export type NativeTranscriptCreateResult = {
+    status: 'created';
+    tail: NativeTranscriptTail;
+} | {
+    status: 'conflict';
+    reason: 'already-exists';
+};
+export type NativeTranscriptReserveResult = {
+    status: 'reserved';
+} | {
+    status: 'conflict';
+    reason: 'already-exists';
+};
+export interface NativeTranscriptLease {
+    reserve(): Promise<NativeTranscriptReserveResult>;
+    load(): Promise<NativeTranscriptSnapshot>;
+    append(expectedTail: NativeTranscriptTail, event: TranscriptEvent): Promise<NativeTranscriptAppendResult>;
+    appendMany(expectedTail: NativeTranscriptTail, events: readonly TranscriptEvent[]): Promise<NativeTranscriptAppendResult>;
+}
+export type NativeTranscriptLeaseResult<T> = {
+    status: 'completed';
+    value: T;
+} | {
+    status: 'conflict';
+    reason: 'locked';
+};
+export declare class NativeTranscriptStore {
+    private readonly options;
+    private readonly lease;
+    constructor(options: {
+        transcriptFile: string;
+        lockFile: string;
+    });
+    private source;
+    private decode;
+    load(): Promise<NativeTranscriptSnapshot>;
+    loadReadOnly(): Promise<NativeTranscriptRecovery>;
+    exportReadOnly(): Promise<Buffer<ArrayBuffer>>;
+    private prepare;
+    create(events: readonly TranscriptEvent[]): Promise<NativeTranscriptCreateResult>;
+    private reserveUnderLease;
+    withLease<T>(operation: (lease: NativeTranscriptLease) => Promise<T>): Promise<NativeTranscriptLeaseResult<T>>;
+    private appendUnderLease;
+    append(expectedTail: NativeTranscriptTail, event: TranscriptEvent): Promise<NativeTranscriptAppendResult>;
+}
+//# sourceMappingURL=native-transcript-store.d.ts.map

package/dist/persistence/native-transcript-store.js

@@ -0,0 +1,321 @@
+import { createHash } from 'node:crypto';
+import { mkdir, open, readFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { ExclusiveFileLease } from '../platform/exclusive-file-lease.js';
+import { createNativeTranscriptCodec } from './native-transcript-codec.js';
+import { classifyTranscriptAppend } from './transcript-file-append.js';
+const hashLine = (line) => createHash('sha256').update(line).digest('hex');
+const emptyTail = () => ({
+    byteLength: 0,
+    lastLineHash: null,
+    lastEventId: null,
+    newlineTerminated: true,
+});
+function splitLines(source) {
+    const end = source.at(-1) === 0x0a ? source.length - 1 : source.length;
+    if (!end)
+        return [];
+    const result = [];
+    let start = 0;
+    for (let i = 0; i < end; i++) {
+        if (source[i] === 0x0a) {
+            result.push(source.subarray(start, i));
+            start = i + 1;
+        }
+    }
+    result.push(source.subarray(start, end));
+    return result;
+}
+function tailFrom(source, records) {
+    const lines = splitLines(source);
+    const line = lines.at(-1);
+    return {
+        byteLength: source.length,
+        lastLineHash: line ? hashLine(line) : null,
+        lastEventId: records.at(-1)?.event.id ?? null,
+        newlineTerminated: source.length === 0 || source.at(-1) === 0x0a,
+    };
+}
+function equalTail(a, b) {
+    return (a.byteLength === b.byteLength &&
+        a.lastLineHash === b.lastLineHash &&
+        a.lastEventId === b.lastEventId &&
+        a.newlineTerminated === b.newlineTerminated);
+}
+function logicalTail(tail) {
+    return tail.branchParentId === undefined
+        ? tail.lastEventId
+        : (tail.branchParentId ?? null);
+}
+function effectiveParentId(event) {
+    return event.kind === 'context-boundary'
+        ? event.logicalParentId
+        : event.parentId;
+}
+function validateHistory(events) {
+    const ids = new Set();
+    const sessions = new Set();
+    const calls = new Set();
+    const children = new Map();
+    for (const [index, event] of events.entries()) {
+        if (ids.has(event.id))
+            throw new Error('Invalid native transcript invariant: event IDs must be unique');
+        if (sessions.size && !sessions.has(event.sessionId))
+            throw new Error('Invalid native transcript invariant: sessionId must match history');
+        if (event.kind === 'context-boundary') {
+            if (event.parentId !== null || !ids.has(event.logicalParentId))
+                throw new Error('Invalid native transcript invariant: context boundary logicalParentId must reference history');
+        }
+        else if (event.parentId === null) {
+            if (index !== 0)
+                throw new Error('Invalid native transcript invariant: only the first logical root may have a null parentId');
+        }
+        else if (!ids.has(event.parentId)) {
+            throw new Error('Invalid native transcript invariant: event parentId must reference an earlier event');
+        }
+        const parentId = effectiveParentId(event);
+        if (parentId !== null) {
+            const siblings = children.get(parentId) ?? [];
+            siblings.push(event);
+            children.set(parentId, siblings);
+        }
+        ids.add(event.id);
+        sessions.add(event.sessionId);
+        if (event.kind !== 'messages')
+            continue;
+        for (const message of event.messages) {
+            if (message.role !== 'assistant')
+                continue;
+            for (const call of message.toolCalls ?? []) {
+                if (calls.has(call.id))
+                    throw new Error('Invalid native transcript invariant: assistant tool-call IDs must be unique');
+                calls.add(call.id);
+            }
+        }
+    }
+    const root = events[0];
+    if (!root)
+        return;
+    const activeCalls = new Set();
+    const activeResults = new Set();
+    const stack = [{ event: root, leaving: false }];
+    while (stack.length > 0) {
+        const frame = stack.pop();
+        if (!frame)
+            break;
+        if (frame.leaving) {
+            for (const id of frame.addedCalls)
+                activeCalls.delete(id);
+            for (const id of frame.addedResults)
+                activeResults.delete(id);
+            continue;
+        }
+        const addedCalls = [];
+        const addedResults = [];
+        if (frame.event.kind === 'messages') {
+            for (const message of frame.event.messages) {
+                if (message.role === 'assistant') {
+                    for (const call of message.toolCalls ?? []) {
+                        activeCalls.add(call.id);
+                        addedCalls.push(call.id);
+                    }
+                }
+                else if (message.role === 'tool') {
+                    if (!activeCalls.has(message.toolCallId))
+                        throw new Error('Invalid native transcript invariant: tool result references unknown tool call on active ancestry');
+                    if (activeResults.has(message.toolCallId))
+                        throw new Error('Invalid native transcript invariant: tool call has multiple results on active ancestry');
+                    activeResults.add(message.toolCallId);
+                    addedResults.push(message.toolCallId);
+                }
+            }
+        }
+        stack.push({
+            event: frame.event,
+            leaving: true,
+            addedCalls,
+            addedResults,
+        });
+        const descendants = children.get(frame.event.id) ?? [];
+        for (let index = descendants.length - 1; index >= 0; index -= 1) {
+            const descendant = descendants[index];
+            if (descendant)
+                stack.push({ event: descendant, leaving: false });
+        }
+    }
+}
+export class NativeTranscriptStore {
+    options;
+    lease;
+    constructor(options) {
+        this.options = options;
+        this.lease = new ExclusiveFileLease(options.lockFile);
+    }
+    async source() {
+        try {
+            return await readFile(this.options.transcriptFile);
+        }
+        catch (e) {
+            if (e.code === 'ENOENT')
+                return Buffer.alloc(0);
+            throw e;
+        }
+    }
+    decode(source, recover) {
+        if (!source.length)
+            return { records: [], tail: emptyTail(), issue: null };
+        const decoded = createNativeTranscriptCodec().decodeDocument(source);
+        if (decoded.issue && !recover)
+            throw new Error(`Invalid native transcript: ${decoded.issue.message}`);
+        if (!recover)
+            validateHistory(decoded.records.map((record) => record.event));
+        return {
+            records: decoded.records,
+            tail: tailFrom(source, decoded.records),
+            issue: decoded.issue,
+        };
+    }
+    async load() {
+        const { records, tail } = this.decode(await this.source(), false);
+        return { records, tail };
+    }
+    async loadReadOnly() {
+        return this.decode(await this.source(), true);
+    }
+    async exportReadOnly() {
+        return this.source();
+    }
+    prepare(history, events, expected) {
+        if (!events.length)
+            throw new Error('Cannot append an empty native transcript batch');
+        const all = history.map((r) => r.event);
+        const historicalIds = new Set(all.map((event) => event.id));
+        if (expected.branchParentId !== undefined &&
+            expected.branchParentId !== null &&
+            !historicalIds.has(expected.branchParentId))
+            throw new Error('Invalid native transcript invariant: branchParentId must reference an earlier event');
+        validateHistory([...history.map((record) => record.event), ...events]);
+        const ids = new Set();
+        const sessions = new Set();
+        for (const e of all) {
+            if (ids.has(e.id))
+                throw new Error('Invalid native transcript invariant: event IDs must be unique');
+            if (sessions.size && !sessions.has(e.sessionId))
+                throw new Error('Invalid native transcript invariant: sessionId must match history');
+            ids.add(e.id);
+            sessions.add(e.sessionId);
+        }
+        let parent = logicalTail(expected);
+        const lines = [];
+        for (const event of events) {
+            const codec = createNativeTranscriptCodec();
+            const encoded = codec.encodeLine(event);
+            if (!encoded.ok)
+                throw new Error(`Invalid native transcript event: ${encoded.issue.message}`);
+            if (ids.has(event.id))
+                throw new Error('Invalid native transcript invariant: event IDs must be unique');
+            if (sessions.size && !sessions.has(event.sessionId))
+                throw new Error('Invalid native transcript invariant: sessionId must match history');
+            sessions.add(event.sessionId);
+            if (event.kind === 'context-boundary') {
+                if (event.parentId !== null || !ids.has(event.logicalParentId))
+                    throw new Error('Invalid native transcript invariant: context boundary logicalParentId must reference history');
+                parent = event.id;
+            }
+            else if (event.parentId !== parent)
+                throw new Error('Invalid native transcript invariant: event parentId does not match logical tail');
+            lines.push(Buffer.from(`${encoded.line}\n`));
+            ids.add(event.id);
+            parent = event.id;
+        }
+        return Buffer.concat(lines);
+    }
+    async create(events) {
+        const bytes = this.prepare([], events, emptyTail());
+        await mkdir(dirname(this.options.transcriptFile), { recursive: true });
+        let handle;
+        try {
+            handle = await open(this.options.transcriptFile, 'wx', 0o600);
+        }
+        catch (e) {
+            if (e.code === 'EEXIST')
+                return { status: 'conflict', reason: 'already-exists' };
+            throw e;
+        }
+        try {
+            await handle.writeFile(bytes);
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        return { status: 'created', tail: (await this.load()).tail };
+    }
+    async reserveUnderLease() {
+        await mkdir(dirname(this.options.transcriptFile), { recursive: true });
+        let handle;
+        try {
+            handle = await open(this.options.transcriptFile, 'wx', 0o600);
+        }
+        catch (e) {
+            if (e.code === 'EEXIST')
+                return { status: 'conflict', reason: 'already-exists' };
+            throw e;
+        }
+        try {
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        return { status: 'reserved' };
+    }
+    async withLease(operation) {
+        const lock = await this.lease.tryAcquire();
+        if (!lock)
+            return { status: 'conflict', reason: 'locked' };
+        try {
+            const value = await operation({
+                reserve: () => this.reserveUnderLease(),
+                load: () => this.load(),
+                append: (tail, event) => this.appendUnderLease(tail, [event]),
+                appendMany: (tail, events) => this.appendUnderLease(tail, events),
+            });
+            return { status: 'completed', value };
+        }
+        finally {
+            await lock.release();
+        }
+    }
+    async appendUnderLease(expected, events) {
+        const current = await this.load();
+        if (!equalTail(current.tail, expected))
+            return { status: 'conflict', reason: 'tail-changed' };
+        if (!current.tail.newlineTerminated)
+            throw new Error('Invalid native transcript: file is not newline-terminated');
+        const bytes = this.prepare(current.records, events, expected);
+        await mkdir(dirname(this.options.transcriptFile), { recursive: true });
+        const handle = await open(this.options.transcriptFile, 'a');
+        try {
+            const stat = await handle.stat();
+            if (stat.size !== expected.byteLength)
+                return { status: 'conflict', reason: 'tail-changed' };
+            await handle.writeFile(bytes);
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        const written = await readFile(this.options.transcriptFile);
+        if (classifyTranscriptAppend(written, expected.byteLength, bytes) ===
+            'interleaved-write')
+            return { status: 'conflict', reason: 'interleaved-write' };
+        const tail = (await this.load()).tail;
+        return { status: 'appended', tail };
+    }
+    async append(expectedTail, event) {
+        const result = await this.withLease((lease) => lease.append(expectedTail, event));
+        return result.status === 'completed' ? result.value : result;
+    }
+}
+//# sourceMappingURL=native-transcript-store.js.map

package/dist/persistence/transcript-file-append.d.ts

@@ -0,0 +1,2 @@
+export declare function classifyTranscriptAppend(written: Uint8Array, previousByteLength: number, encodedLine: Uint8Array): 'appended' | 'interleaved-write';
+//# sourceMappingURL=transcript-file-append.d.ts.map

package/dist/persistence/transcript-file-append.js

@@ -0,0 +1,10 @@
+export function classifyTranscriptAppend(written, previousByteLength, encodedLine) {
+    const expectedEnd = previousByteLength + encodedLine.length;
+    if (written.length === expectedEnd &&
+        Buffer.from(written)
+            .subarray(previousByteLength, expectedEnd)
+            .equals(encodedLine))
+        return 'appended';
+    return 'interleaved-write';
+}
+//# sourceMappingURL=transcript-file-append.js.map

package/dist/tools/claude-capabilities.d.ts

@@ -25,6 +25,7 @@ export interface ClaudeToolCapabilityInput {
     readonly agentTriggers?: boolean;
     readonly backgroundAgents?: boolean;
     readonly subagents?: boolean;
+    readonly teams?: boolean;
     /** Explicit allow-list for capability-gated tools; never enables a gate. */
     readonly tools?: readonly string[];
     /** Always wins over the allow-list and the default rules. */
@@ -35,6 +36,7 @@ export interface ClaudeToolCapabilityInput {
 export declare const CLAUDE_CODE_ENABLE_TASKS = "CLAUDE_CODE_ENABLE_TASKS";
 export declare const CLAUDE_CODE_DISABLE_CRON = "CLAUDE_CODE_DISABLE_CRON";
 export declare const PRAXIS_ENABLE_WORKFLOW_SCRIPTS = "PRAXIS_ENABLE_WORKFLOW_SCRIPTS";
+export declare const PRAXIS_ENABLE_TEAMS = "PRAXIS_ENABLE_TEAMS";
 /** task-v2 task-board tools, gated by the `tasks` capability. */
 export declare const CLAUDE_TASK_V2_TOOLS: readonly ["TaskCreate", "TaskGet", "TaskList", "TaskUpdate"];
 /** Workflow tool, gated by the `workflowScripts` capability. */
@@ -45,6 +47,8 @@ export declare const CLAUDE_AGENT_TRIGGER_TOOLS: readonly ["CronCreate", "CronDe
 export declare const CLAUDE_AGENT_TOOLS: readonly ["Agent"];
 /** Background task lifecycle tools, gated by the `backgroundAgents` capability. */
 export declare const CLAUDE_BACKGROUND_TOOLS: readonly ["TaskOutput", "TaskStop"];
+/** Experimental local Team lifecycle names, gated by `PRAXIS_ENABLE_TEAMS`. */
+export declare const PRAXIS_TEAM_TOOLS: readonly ["TeamCreate", "TeamResume", "TeamList", "TeamAccept", "TeamStop", "TeamSend"];
 /** Coordination tools advertised by a coordinator only when explicitly enabled. */
 export declare const CLAUDE_COORDINATION_TOOLS: readonly ["AskUserQuestion", "SendMessage", "SendUserMessage", "Monitor", "PushNotification"];
 /** Recursively suppressed for worker agents regardless of any allow-list. */