@nomix-ai/nomix-harness 0.2.5 → 0.2.6

package/dist/kernel/experimental-agent-team/lib/types/task-board.js

@@ -0,0 +1,275 @@
+/** Shared Team task DAG commands and runtime-enriched views. */
+import { TeamError } from "./error.js";
+import { resolveActiveMember } from "./roster.js";
+import { assertTaskGraphCandidate, TeamTaskGraphError } from "./task-graph.js";
+import { TeamId, TeamTaskId } from "./types.js";
+import { requiredText, writeScope } from "./validation.js";
+/** Whether two normalized file or directory prefixes overlap on path components. */
+function scopesOverlap(left, right) {
+    return left === right || left.startsWith(`${right}/`) || right.startsWith(`${left}/`);
+}
+const TASK_GRAPH_ERROR_CODES = {
+    missing: 'TEAM_TASK_NOT_FOUND',
+    duplicate: 'TEAM_INVALID_ARGUMENT',
+    cycle: 'TEAM_TASK_DEPENDENCY_CYCLE',
+};
+/** Owns Team task limits, authorization, transitions, and derived views. */
+export class TeamTaskBoard {
+    journal;
+    maxTasks;
+    /**
+     * @param journal - authoritative Lead-log transaction owner.
+     * @param maxTasks - maximum non-deleted tasks retained by one Team.
+     */
+    constructor(journal, maxTasks) {
+        this.journal = journal;
+        this.maxTasks = maxTasks;
+    }
+    /**
+     * Create one unowned pending task in the Team Lead log.
+     * @param membership - exact caller membership resolved by the Team roster.
+     * @param request - task text, blockers, and advisory write scopes.
+     * @returns the revision-one task view.
+     */
+    async create(membership, request) {
+        const { root } = membership;
+        return this.journal.transact(root.id, async () => {
+            const state = this.journal.state(root);
+            const active = [...state.tasks.values()].filter(task => task.status !== 'deleted').length;
+            if (active >= this.maxTasks) {
+                throw new TeamError(`Team task limit ${this.maxTasks} reached`, 'TEAM_TASK_LIMIT');
+            }
+            const id = TeamTaskId(`task-${state.nextTaskNumber}`);
+            if (state.tasks.has(id)) {
+                throw new TeamError('Team task id space exhausted', 'TEAM_TASK_LIMIT');
+            }
+            const task = {
+                id,
+                revision: 1,
+                subject: requiredText(request.subject, 'subject', 200),
+                description: requiredText(request.description, 'description', 16_384),
+                status: 'pending',
+                blockedBy: this.dependencies(request.blockedBy ?? [], state),
+                writeScopes: this.writeScopes(request.writeScopes ?? []),
+            };
+            this.assertTaskGraph(state, task);
+            await this.journal.appendAndFlush(root, 'team/task', { version: 1, teamId: TeamId(root.id), task });
+            return this.taskView(root, state, task);
+        });
+    }
+    /**
+     * Return one task, including a deleted tombstone.
+     * @param membership - exact caller membership resolved by the Team roster.
+     * @param id - Team-local task identity.
+     * @returns the latest task value and derived readiness diagnostics.
+     */
+    get(membership, id) {
+        const { root } = membership;
+        const state = this.journal.state(root);
+        const task = state.tasks.get(id);
+        if (task === undefined)
+            throw new TeamError(`team task "${id}" not found`, 'TEAM_TASK_NOT_FOUND');
+        return this.taskView(root, state, task);
+    }
+    /**
+     * List current non-deleted tasks in numeric creation order.
+     * @param membership - exact caller membership resolved by the Team roster.
+     * @returns detached current task views.
+     */
+    list(membership) {
+        const { root } = membership;
+        const state = this.journal.state(root);
+        return [...state.tasks.values()]
+            .filter(task => task.status !== 'deleted')
+            .map(task => this.taskView(root, state, task));
+    }
+    /**
+     * Compare-and-set one authorized task transition.
+     * @param caller - exact live Team member authorizing the mutation.
+     * @param membership - caller role and exact live Lead.
+     * @param request - task identity, expected revision, action, and action fields.
+     * @returns the committed next task revision.
+     */
+    async update(caller, membership, request) {
+        const root = membership.root;
+        return this.journal.transact(root.id, async () => {
+            const state = this.journal.state(root);
+            const current = state.tasks.get(request.taskId);
+            if (current === undefined)
+                throw new TeamError(`team task "${request.taskId}" not found`, 'TEAM_TASK_NOT_FOUND');
+            if (current.revision !== request.expectedRevision) {
+                throw new TeamError(`stale team task "${current.id}" revision ${request.expectedRevision}; current revision is ${current.revision}`, 'TEAM_TASK_STALE_REVISION');
+            }
+            if (current.status === 'deleted')
+                throw new TeamError(`team task "${current.id}" is deleted`, 'TEAM_TASK_DELETED');
+            const lead = membership.role === 'lead';
+            const owner = current.ownerId === caller.id;
+            const authorizeOwner = () => {
+                if (!lead && !owner)
+                    throw new TeamError('task mutation requires its owner or Team Lead', 'TEAM_TASK_UNAUTHORIZED');
+            };
+            let next;
+            switch (request.action) {
+                case 'claim':
+                    if (current.ownerId !== undefined && current.ownerId !== caller.id) {
+                        throw new TeamError(`team task "${current.id}" is owned by another member`, 'TEAM_TASK_ALREADY_CLAIMED');
+                    }
+                    if (current.status !== 'pending' || !this.taskReady(state, current)) {
+                        throw new TeamError(`team task "${current.id}" is not ready to claim`, 'TEAM_TASK_BLOCKED');
+                    }
+                    next = { ...current, status: 'in_progress', ownerId: caller.id };
+                    break;
+                case 'release':
+                    authorizeOwner();
+                    if (current.status !== 'in_progress')
+                        throw new TeamError('only an in-progress task can be released', 'TEAM_TASK_INVALID_TRANSITION');
+                    next = this.withoutOwner({ ...current, status: 'pending' });
+                    break;
+                case 'edit':
+                    authorizeOwner();
+                    if (request.subject === undefined && request.description === undefined && request.writeScopes === undefined) {
+                        throw new TeamError('task edit requires subject, description, or write_scopes', 'TEAM_INVALID_ARGUMENT');
+                    }
+                    next = {
+                        ...current,
+                        ...request.subject === undefined ? {} : { subject: requiredText(request.subject, 'subject', 200) },
+                        ...request.description === undefined
+                            ? {}
+                            : { description: requiredText(request.description, 'description', 16_384) },
+                        ...request.writeScopes === undefined ? {} : { writeScopes: this.writeScopes(request.writeScopes) },
+                    };
+                    break;
+                case 'set_dependencies':
+                    authorizeOwner();
+                    if (request.blockedBy === undefined)
+                        throw new TeamError('set_dependencies requires blocked_by', 'TEAM_INVALID_ARGUMENT');
+                    next = { ...current, blockedBy: this.dependencies(request.blockedBy, state, current.id) };
+                    break;
+                case 'complete':
+                    authorizeOwner();
+                    if (current.status !== 'in_progress')
+                        throw new TeamError('only an in-progress task can complete', 'TEAM_TASK_INVALID_TRANSITION');
+                    next = { ...current, status: 'completed' };
+                    break;
+                case 'reopen':
+                    authorizeOwner();
+                    if (current.status !== 'completed')
+                        throw new TeamError('only a completed task can reopen', 'TEAM_TASK_INVALID_TRANSITION');
+                    next = this.withoutOwner({ ...current, status: 'pending' });
+                    break;
+                case 'reassign': {
+                    if (!lead)
+                        throw new TeamError('only the Team Lead can reassign tasks', 'TEAM_LEAD_REQUIRED');
+                    if (current.status !== 'pending' && current.status !== 'in_progress') {
+                        throw new TeamError('only a pending or in-progress task can be reassigned', 'TEAM_TASK_INVALID_TRANSITION');
+                    }
+                    if (request.owner === undefined || request.owner.trim().length === 0) {
+                        next = this.withoutOwner({ ...current, status: 'pending' });
+                        break;
+                    }
+                    if (!this.taskReady(state, current))
+                        throw new TeamError(`team task "${current.id}" is blocked`, 'TEAM_TASK_BLOCKED');
+                    const assignee = resolveActiveMember(root, state, request.owner);
+                    next = { ...current, status: 'in_progress', ownerId: assignee.id };
+                    break;
+                }
+                case 'delete': {
+                    authorizeOwner();
+                    const dependent = [...state.tasks.values()].find(task => task.status !== 'deleted' && task.id !== current.id && task.blockedBy.includes(current.id));
+                    if (dependent !== undefined) {
+                        throw new TeamError(`team task "${current.id}" still blocks "${dependent.id}"`, 'TEAM_TASK_HAS_DEPENDENTS');
+                    }
+                    next = { ...current, status: 'deleted' };
+                    break;
+                }
+                /* v8 ignore next 2 -- TeamTaskAction is closed and every member is handled above. */
+                default:
+                    throw new TeamError(`unsupported task action ${String(request.action)}`, 'TEAM_INVALID_ARGUMENT');
+            }
+            const task = {
+                ...next,
+                revision: current.revision + 1,
+            };
+            this.assertTaskGraph(state, task);
+            await this.journal.appendAndFlush(root, 'team/task', { version: 1, teamId: TeamId(root.id), task });
+            return this.taskView(root, state, task);
+        });
+    }
+    /** Validate and de-duplicate dependency ids against the current task graph. */
+    dependencies(values, state, self) {
+        const seen = new Set();
+        const result = [];
+        for (const id of values) {
+            if (id === self)
+                throw new TeamError('a team task cannot block itself', 'TEAM_TASK_DEPENDENCY_CYCLE');
+            if (seen.has(id))
+                throw new TeamError(`duplicate blocker "${id}"`, 'TEAM_INVALID_ARGUMENT');
+            const task = state.tasks.get(id);
+            if (task === undefined || task.status === 'deleted') {
+                throw new TeamError(`blocker task "${id}" not found`, 'TEAM_TASK_NOT_FOUND');
+            }
+            seen.add(id);
+            result.push(id);
+        }
+        return result;
+    }
+    /** Normalize and de-duplicate task write scopes. */
+    writeScopes(values) {
+        return [...new Set(values.map(writeScope))];
+    }
+    /** Map shared task-graph validation onto stable command error codes. */
+    assertTaskGraph(state, candidate) {
+        try {
+            assertTaskGraphCandidate(state.tasks, candidate);
+        }
+        catch (error) {
+            /* v8 ignore next -- the shared validator is the only statement in the try and throws this exact error. */
+            if (!(error instanceof TeamTaskGraphError))
+                throw error;
+            throw new TeamError(error.message, TASK_GRAPH_ERROR_CODES[error.violation], { cause: error });
+        }
+    }
+    /** Whether all current blockers completed. */
+    taskReady(state, task) {
+        return task.blockedBy.every(id => state.tasks.get(id)?.status === 'completed');
+    }
+    /** Remove an optional owner field under exactOptionalPropertyTypes. */
+    withoutOwner(task) {
+        const { ownerId: _ownerId, ...without } = task;
+        return without;
+    }
+    /**
+     * Build one task view with owner name, readiness, and advisory write overlaps.
+     * A committing caller may pass its pre-append fold because `task` supplies the
+     * new value explicitly; owner names, blocker readiness, and other task scopes
+     * do not change when that snapshot is appended.
+     */
+    taskView(root, state, task) {
+        const ownerName = task.ownerId === undefined
+            ? undefined
+            : task.ownerId === root.id
+                ? 'lead'
+                : state.members.get(task.ownerId)?.name;
+        const warnings = new Set();
+        for (const other of state.tasks.values()) {
+            if (other.id === task.id || other.status !== 'in_progress')
+                continue;
+            if (task.writeScopes.some(left => other.writeScopes.some(right => scopesOverlap(left, right)))) {
+                warnings.add(`write scopes overlap with ${other.id}`);
+            }
+        }
+        return {
+            id: task.id,
+            revision: task.revision,
+            subject: task.subject,
+            description: task.description,
+            status: task.status,
+            blockedBy: structuredClone(task.blockedBy),
+            writeScopes: structuredClone(task.writeScopes),
+            ...ownerName === undefined ? {} : { ownerName },
+            ready: task.status === 'pending' && this.taskReady(state, task),
+            writeScopeWarnings: [...warnings],
+        };
+    }
+}
+//# sourceMappingURL=task-board.js.map

package/dist/kernel/experimental-agent-team/lib/types/task-graph.d.ts

@@ -0,0 +1,21 @@
+/** Complete dependency validation for current Team task snapshots. */
+import type { TeamTaskId, TeamTaskSnapshot } from './types.ts';
+/** Task dependency relation rejected by the shared graph validator. */
+export type TeamTaskGraphViolation = 'missing' | 'duplicate' | 'cycle';
+/** Package-private task dependency failure retained for command error mapping. */
+export declare class TeamTaskGraphError extends Error {
+    readonly violation: TeamTaskGraphViolation;
+    /**
+     * @param message - concrete invalid dependency relation.
+     * @param violation - stable relation category used by Team commands.
+     */
+    constructor(message: string, violation: TeamTaskGraphViolation);
+}
+/**
+ * Validate the complete active task graph after replacing one candidate snapshot.
+ * @param current - current task snapshots before the candidate event.
+ * @param candidate - new or next-revision task snapshot.
+ * @throws {TeamTaskGraphError} when an active dependency is missing, duplicated, self-referential, or cyclic.
+ */
+export declare function assertTaskGraphCandidate(current: ReadonlyMap<TeamTaskId, TeamTaskSnapshot>, candidate: TeamTaskSnapshot): void;
+//# sourceMappingURL=task-graph.d.ts.map

package/dist/kernel/experimental-agent-team/lib/types/task-graph.js

@@ -0,0 +1,62 @@
+/** Complete dependency validation for current Team task snapshots. */
+/** Package-private task dependency failure retained for command error mapping. */
+export class TeamTaskGraphError extends Error {
+    violation;
+    /**
+     * @param message - concrete invalid dependency relation.
+     * @param violation - stable relation category used by Team commands.
+     */
+    constructor(message, violation) {
+        super(message);
+        this.violation = violation;
+        this.name = 'TeamTaskGraphError';
+    }
+}
+/**
+ * Validate the complete active task graph after replacing one candidate snapshot.
+ * @param current - current task snapshots before the candidate event.
+ * @param candidate - new or next-revision task snapshot.
+ * @throws {TeamTaskGraphError} when an active dependency is missing, duplicated, self-referential, or cyclic.
+ */
+export function assertTaskGraphCandidate(current, candidate) {
+    const tasks = new Map(current);
+    tasks.set(candidate.id, candidate);
+    for (const task of tasks.values()) {
+        if (task.status === 'deleted')
+            continue;
+        const seen = new Set();
+        for (const blockerId of task.blockedBy) {
+            if (blockerId === task.id) {
+                throw new TeamTaskGraphError(`team task "${task.id}" cannot block itself`, 'cycle');
+            }
+            if (seen.has(blockerId)) {
+                throw new TeamTaskGraphError(`team task "${task.id}" repeats blocker "${blockerId}"`, 'duplicate');
+            }
+            const blocker = tasks.get(blockerId);
+            if (blocker === undefined || blocker.status === 'deleted') {
+                throw new TeamTaskGraphError(`blocker task "${blockerId}" for "${task.id}" is missing or deleted`, 'missing');
+            }
+            seen.add(blockerId);
+        }
+    }
+    const visiting = new Set();
+    const visited = new Set();
+    const visit = (id) => {
+        if (visiting.has(id)) {
+            throw new TeamTaskGraphError(`task dependency cycle includes "${id}"`, 'cycle');
+        }
+        if (visited.has(id))
+            return;
+        const task = tasks.get(id);
+        if (task === undefined || task.status === 'deleted')
+            return;
+        visiting.add(id);
+        for (const blockerId of task.blockedBy)
+            visit(blockerId);
+        visiting.delete(id);
+        visited.add(id);
+    };
+    for (const task of tasks.values())
+        visit(task.id);
+}
+//# sourceMappingURL=task-graph.js.map

package/dist/kernel/experimental-agent-team/lib/types/types.d.ts

@@ -0,0 +1,192 @@
+/** Public Agent Teams identities, durable records, and service request values. */
+import type { Branded } from '../../../brand/lib/index.js';
+import type { ContentBlock } from '../../../llm/lib/index.js';
+import type { SessionId } from '../../../session/lib/index.js';
+/** Identifies the implicit team rooted at one top-level Session. */
+export type TeamId = Branded<'TeamId'>;
+/**
+ * Brand one root Session identity as its implicit Team identity.
+ * @param id - Root Session identity.
+ * @returns the same string branded as a Team identity.
+ */
+export declare function TeamId(id: SessionId | string): TeamId;
+/** Stable identifier for one task in a Team. */
+export type TeamTaskId = Branded<'TeamTaskId'>;
+/**
+ * Brand a validated task id.
+ * @param id - Team-local task identity.
+ * @returns the same string branded as a Team task identity.
+ */
+export declare function TeamTaskId(id: string): TeamTaskId;
+/** Stable identifier for one durable peer message. */
+export type TeamMessageId = Branded<'TeamMessageId'>;
+/**
+ * Brand a generated peer-message id.
+ * @param id - Durable mailbox message identity.
+ * @returns the same string branded as a Team message identity.
+ */
+export declare function TeamMessageId(id: string): TeamMessageId;
+/** Durable teammate lifecycle. */
+export type TeamMemberPhase = 'provisioning' | 'active' | 'failed';
+/** Whole durable value written on every teammate lifecycle change. */
+export interface TeamMemberSnapshot {
+    readonly id: SessionId;
+    readonly name: string;
+    readonly description: string;
+    readonly provider: string;
+    readonly context: 'fresh' | 'fork';
+    readonly phase: TeamMemberPhase;
+    readonly error?: string;
+}
+/** Current runtime-enriched roster row. */
+export interface TeamMemberView {
+    readonly id: SessionId;
+    readonly name: string;
+    readonly role: 'lead' | 'teammate';
+    readonly status: 'running' | 'idle' | 'inactive' | 'provisioning' | 'failed';
+    readonly description?: string;
+    readonly provider?: string;
+    readonly context?: 'fresh' | 'fork';
+    readonly model?: string;
+    readonly diagnostics: string[];
+}
+/** Durable task lifecycle. */
+export type TeamTaskStatus = 'pending' | 'in_progress' | 'completed' | 'deleted';
+/** Whole durable task snapshot; every mutation increments {@link revision}. */
+export interface TeamTaskSnapshot {
+    readonly id: TeamTaskId;
+    readonly revision: number;
+    readonly subject: string;
+    readonly description: string;
+    readonly status: TeamTaskStatus;
+    readonly ownerId?: SessionId;
+    readonly blockedBy: TeamTaskId[];
+    readonly writeScopes: string[];
+}
+/** Runtime-enriched task view returned to tools and hosts. */
+export interface TeamTaskView {
+    readonly id: TeamTaskId;
+    readonly revision: number;
+    readonly subject: string;
+    readonly description: string;
+    readonly status: TeamTaskStatus;
+    readonly blockedBy: TeamTaskId[];
+    readonly writeScopes: string[];
+    readonly ownerName?: string;
+    readonly ready: boolean;
+    readonly writeScopeWarnings: string[];
+}
+/** One peer message retained until its target Session records it. */
+export interface TeamMessageSnapshot {
+    readonly id: TeamMessageId;
+    readonly senderId: SessionId;
+    readonly senderName: string;
+    readonly targetId: SessionId;
+    readonly delivery: 'quiet' | 'wakeup';
+    readonly content: ContentBlock[];
+}
+/** Source retained by the target Session for durable mailbox de-duplication. */
+export interface TeamMessageSource {
+    readonly kind: 'team-message';
+    readonly teamId: TeamId;
+    readonly messageId: TeamMessageId;
+    readonly senderId: SessionId;
+    readonly senderName: string;
+}
+declare module '@nomix-ai/nomix-llm' {
+    interface MessageSourceMap {
+        'team-message': TeamMessageSource;
+    }
+}
+/** Team-service deployment limits. */
+export interface Config {
+    /** Maximum immutable teammate names retained by one Team. */
+    readonly maxMembers?: number;
+    /** Maximum non-deleted tasks retained by one Team. */
+    readonly maxTasks?: number;
+    /** Maximum queued-minus-delivered messages for one target member. */
+    readonly maxPendingMessagesPerMember?: number;
+    /** Maximum UTF-8 bytes in one complete sender-framed delivery. */
+    readonly maxMessageBytes?: number;
+    /** Maximum milliseconds allowed for Team-owned runtime disposal. */
+    readonly disposalTimeoutMs?: number;
+}
+/** Input for creating one durable teammate. */
+export interface SpawnTeammateRequest {
+    readonly name: string;
+    readonly description: string;
+    readonly prompt: ContentBlock[];
+    readonly context: 'fresh' | 'fork';
+    readonly provider: string;
+    readonly signal: AbortSignal;
+}
+/** Result after one teammate reaches a durable active or failed edge. */
+export interface SpawnTeammateResult {
+    readonly member: TeamMemberView;
+}
+/** Input for one durable peer message. */
+export interface SendTeamMessageRequest {
+    readonly target: string;
+    readonly content: ContentBlock[];
+    readonly delivery: 'quiet' | 'wakeup';
+    readonly signal: AbortSignal;
+}
+/** Result after a peer message enters the durable mailbox. */
+export interface SendTeamMessageResult {
+    readonly messageId: TeamMessageId;
+    readonly status: 'accepted' | 'queued';
+}
+/** Input for creating one shared task. */
+export interface CreateTeamTaskRequest {
+    readonly subject: string;
+    readonly description: string;
+    readonly blockedBy?: readonly TeamTaskId[];
+    readonly writeScopes?: readonly string[];
+}
+/** Supported task mutation actions. */
+export type TeamTaskAction = 'claim' | 'release' | 'edit' | 'set_dependencies' | 'complete' | 'reopen' | 'reassign' | 'delete';
+/** Compare-and-set mutation of one shared task. */
+export interface UpdateTeamTaskRequest {
+    readonly taskId: TeamTaskId;
+    readonly expectedRevision: number;
+    readonly action: TeamTaskAction;
+    readonly subject?: string;
+    readonly description?: string;
+    readonly blockedBy?: readonly TeamTaskId[];
+    readonly writeScopes?: readonly string[];
+    readonly owner?: string;
+}
+/** Result of waiting for Team activity. */
+export interface TeamWaitResult {
+    readonly timedOut: boolean;
+}
+declare module '@nomix-ai/nomix-session/types' {
+    interface SessionEventMap {
+        /** Whole teammate lifecycle value, stored only in the Team Lead Session. */
+        'team/member': {
+            version: 1;
+            teamId: TeamId;
+            member: TeamMemberSnapshot;
+        };
+        /** Whole shared-task value, stored only in the Team Lead Session. */
+        'team/task': {
+            version: 1;
+            teamId: TeamId;
+            task: TeamTaskSnapshot;
+        };
+        /** Durable mailbox enqueue, stored before delivery is attempted. */
+        'team/message/queued': {
+            version: 1;
+            teamId: TeamId;
+            message: TeamMessageSnapshot;
+        };
+        /** Durable acknowledgement that the target Session recorded the message. */
+        'team/message/delivered': {
+            version: 1;
+            teamId: TeamId;
+            messageId: TeamMessageId;
+            targetId: SessionId;
+        };
+    }
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/kernel/experimental-agent-team/lib/types/types.js

@@ -0,0 +1,26 @@
+/** Public Agent Teams identities, durable records, and service request values. */
+/**
+ * Brand one root Session identity as its implicit Team identity.
+ * @param id - Root Session identity.
+ * @returns the same string branded as a Team identity.
+ */
+export function TeamId(id) {
+    return id;
+}
+/**
+ * Brand a validated task id.
+ * @param id - Team-local task identity.
+ * @returns the same string branded as a Team task identity.
+ */
+export function TeamTaskId(id) {
+    return id;
+}
+/**
+ * Brand a generated peer-message id.
+ * @param id - Durable mailbox message identity.
+ * @returns the same string branded as a Team message identity.
+ */
+export function TeamMessageId(id) {
+    return id;
+}
+//# sourceMappingURL=types.js.map

package/dist/kernel/experimental-agent-team/lib/types/validation.d.ts

@@ -0,0 +1,16 @@
+/** Input normalization shared by Team roster and task commands. */
+/**
+ * Normalize one required human-authored string.
+ * @param value - raw input value.
+ * @param field - diagnostic field name.
+ * @param maxLength - maximum normalized character count.
+ * @returns trimmed non-empty text.
+ */
+export declare function requiredText(value: string, field: string, maxLength: number): string;
+/**
+ * Normalize one workspace-relative path prefix without treating it as a lock.
+ * @param value - user-authored path prefix.
+ * @returns normalized slash-separated prefix.
+ */
+export declare function writeScope(value: string): string;
+//# sourceMappingURL=validation.d.ts.map

package/dist/kernel/experimental-agent-team/lib/types/validation.js

@@ -0,0 +1,33 @@
+/** Input normalization shared by Team roster and task commands. */
+import { TeamError } from "./error.js";
+/**
+ * Normalize one required human-authored string.
+ * @param value - raw input value.
+ * @param field - diagnostic field name.
+ * @param maxLength - maximum normalized character count.
+ * @returns trimmed non-empty text.
+ */
+export function requiredText(value, field, maxLength) {
+    const text = value.trim();
+    if (text.length === 0)
+        throw new TeamError(`${field} must be non-empty`, 'TEAM_INVALID_ARGUMENT');
+    if (text.length > maxLength) {
+        throw new TeamError(`${field} exceeds ${maxLength} characters`, 'TEAM_INVALID_ARGUMENT');
+    }
+    return text;
+}
+/**
+ * Normalize one workspace-relative path prefix without treating it as a lock.
+ * @param value - user-authored path prefix.
+ * @returns normalized slash-separated prefix.
+ */
+export function writeScope(value) {
+    const normalized = value.replaceAll('\\', '/').replace(/^\.\//u, '').replace(/\/+$/u, '');
+    const segments = normalized.split('/');
+    if (normalized.length === 0 || normalized.startsWith('/') || /^[a-z]:/iu.test(normalized)
+        || segments.some(segment => segment.length === 0 || segment === '.' || segment === '..')) {
+        throw new TeamError(`invalid workspace-relative write scope ${JSON.stringify(value)}`, 'TEAM_INVALID_WRITE_SCOPE');
+    }
+    return normalized;
+}
+//# sourceMappingURL=validation.js.map