crow-central-agency 0.24.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 hmmroger
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,139 @@
+# Crow Central Agency
+
+Multi-instance Claude Code manager with a bundled web UI for orchestrating multiple Claude Code agents from one place.
+
+Use it to build research crews, monitoring watchdogs, content pipelines, support triagers, or anything else you can shape from agents coordinating with each other.
+
+## Features
+
+- **Multi-agent dashboard** - run many Claude Code agents in parallel, each with its own workspace, model, persona, and tool set.
+- **Agent coordination** - compose agents into layered relationships that produce and share artifacts, adaptable to a wide range of workflows and scenarios.
+- **Flexible triggers** - ad-hoc chat, assigned tasks, reminders, or scheduled prompts on configurable day-of-week / time-of-day windows.
+- **Rich configuration** - per-agent MCP servers, permission modes, Discord bots, RSS feeds (with optional LLM summarization), and AI-assisted persona / `AGENT.md` generation.
+- **OpenTelemetry export** - optional traces and metrics for every agent query (see below).
+
+## Requirements
+
+- Node.js `>=24`
+- Claude Code CLI available on `PATH` (or set `CLAUDE_CLI_PATH`)
+
+## Quick start
+
+1. **Install Node.js `>=24`.** Check your version with `node --version`. If it is missing or older, install from [nodejs.org](https://nodejs.org/) or use [nvm](https://github.com/nvm-sh/nvm) (`nvm install 24 && nvm use 24`).
+
+2. **Install the Claude Code CLI.** Make sure the `claude` command is on your `PATH` (or point `CLAUDE_CLI_PATH` at the binary). Verify with `claude --version`.
+
+3. **Create a `.env` file with an `ACCESS_KEY`.** Pick any non-empty string — a long random value is recommended. A dedicated folder like `~/.crow` keeps it out of your project directories:
+
+   ```bash
+   mkdir -p ~/.crow
+   echo "ACCESS_KEY=your-secret-value" > ~/.crow/.env
+   ```
+
+   TIP: Generate a strong value with `openssl rand -hex 32`.
+
+4. **Start Crow**, pointing at the env file you just created:
+
+   ```bash
+   npx crow-central-agency --env-file ~/.crow/.env
+   ```
+
+5. **Open [http://localhost:3101](http://localhost:3101)** in your browser. On first load the UI prompts for the access key — paste the same value you set in step 3.
+
+### Run from a cloned repo
+
+```bash
+git clone https://github.com/hmmroger/crow-central-agency.git
+cd crow-central-agency
+npm install
+npm run build
+npm start -- --env-file ~/.crow/.env
+```
+
+`npm start` runs the same single-box entry point as the published CLI.
+
+## Configuration
+
+Crow reads configuration from environment variables. The simplest approach is to copy `.env.example` to `.env` in the directory you launch from — `dotenv` loads it automatically on startup.
+
+```bash
+cp .env.example .env
+```
+
+### Required: `ACCESS_KEY`
+
+`ACCESS_KEY` is the only required variable. It is a shared secret between the server and the browser UI — you **choose the value yourself**; there is no default and no external provisioning.
+
+1. Pick any non-empty string (a long random value is recommended, e.g. `openssl rand -hex 32`).
+2. Set `ACCESS_KEY=<your value>` in `.env`.
+3. On first load, the web UI prompts for the access key — enter the same value. It is then stored in the browser and sent as `Authorization: Bearer <key>` on API requests (and as a query param on the WebSocket connection).
+
+Requests without a valid key receive `401 Unauthorized`.
+
+### Custom env file path
+
+To load a `.env` from a non-default location, pass `--env-file`:
+
+```bash
+npx crow-central-agency --env-file /path/to/custom.env
+```
+
+The same flag works with `npm start` when running from a clone:
+
+```bash
+npm start -- --env-file /path/to/custom.env
+```
+
+If `--env-file` is omitted, `dotenv` falls back to `.env` in the current working directory.
+
+### Other variables
+
+See `.env.example` for the full list, including:
+
+- `HOST` / `PORT` — server bind address (defaults: `localhost:3101`). Keep `HOST=localhost` and front the server with a secure tunnel for remote access rather than binding to `0.0.0.0`.
+- `CORS_ORIGINS` — only needed when the frontend is served from a different origin (e.g. during frontend dev). Single-box deployments can leave it unset.
+- `CROW_SYSTEM_PATH` — directory for Crow's file-based storage. Defaults to `~/.crow`.
+- `TEXT_GENERATION_*` — optional OpenAI-compatible endpoint that enables the AI-assisted persona / `AGENT.md` generation features in the agent editor.
+- `FEED_TEXT_GENERATION_*` — optional OpenAI-compatible endpoint used by the feed manager to summarize feed items into a consistent length for better agent consumption.
+- `OTEL_*` — optional OpenTelemetry export.
+- `ANTHROPIC_API_KEY` — Anthropic API key.
+
+## OpenTelemetry
+
+Crow emits traces and metrics via `@opentelemetry/sdk-node`. Telemetry is off by default — set `OTEL_ENABLED=true` along with the standard OTel env vars (`OTEL_SERVICE_NAME`, `OTEL_EXPORTER_OTLP_ENDPOINT`, etc.) to export to your collector.
+
+Built-in HTTP/Fastify/Undici instrumentations cover inbound requests and outgoing HTTP calls. On top of that, Crow adds agent-query instrumentation under the `crow.agent` tracer and meter.
+
+> [!NOTE]
+> Unlike typical operational telemetry, Crow's spans include user-authored content on attributes and events — notably `agent.name` and `tool.description` (the latter often derived from tool-use input). Error messages and recorded exceptions (`agent.error`) may also contain PII surfaced from underlying tools or model output. Anything you export is visible to whatever OTel backend you point at, so only send telemetry to a provider you trust.
+
+### Traces — `crow.agent`
+
+One span per agent query, named `agent.query`.
+
+Span attributes:
+
+- `agent.id`, `agent.name` — identity of the agent being queried
+- `agent.source_type` — what triggered the query (e.g. `USER`, `TASK`, `LOOP`)
+- `agent.session_id` — Claude Code session id (set once the `INIT` event arrives)
+- `agent.done_type` — terminal reason (`aborted`, or the done-event type on success)
+- `agent.duration_ms` — total query duration
+- `agent.error` — error message on failure (span status set to `ERROR`, exception recorded with stack trace)
+
+Span events:
+
+- `tool_use` — emitted per tool invocation with `tool.name` and `tool.description`
+- `message_done` — emitted per assistant message with `message.input_tokens`, `message.output_tokens`, `message.total_input_tokens` (the last includes cache-read and cache-creation tokens)
+
+### Metrics — `crow.agent`
+
+All metrics are tagged with `agent.id` and `agent.name`.
+
+- `agent.query.input_tokens` (histogram, unit `tokens`) — total input tokens per assistant message, including cache-read and cache-creation tokens
+- `agent.query.output_tokens` (histogram, unit `tokens`) — output tokens per assistant message
+- `agent.query.duration` (histogram, unit `s`) — total duration of each agent query
+- `agent.query.tool_use` (counter, unit `invocations`) — tool invocations, additionally tagged with `tool.name`
+
+## License
+
+MIT

package/dist/_shared/constants/system-agent.js

@@ -0,0 +1,4 @@
+/** Well-known ID for the Crow system agent */
+export const CROW_SYSTEM_AGENT_ID = "__super_crow__";
+export const CROW_TASK_DISPATCHER_AGENT_ID = "__crow_task_dp__";
+//# sourceMappingURL=system-agent.js.map

package/dist/_shared/constants/system-circle.js

@@ -0,0 +1,7 @@
+/**
+ * Well-known system circle constants.
+ * The Base Circle is a built-in circle for agents with no explicit circle membership.
+ */
+export const BASE_CIRCLE_ID = "__base_circle__";
+export const BASE_CIRCLE_NAME = "Crow Circle";
+//# sourceMappingURL=system-circle.js.map

package/dist/_shared/index.js

@@ -0,0 +1,22 @@
+export { CLAUDE_MODELS, CLAUDE_CODE_MODEL_OPTIONS, DEFAULT_MODEL, AgentIdSchema, AgentConfigSchema, AgentConfigTemplateSchema, CreateAgentInputSchema, UpdateAgentInputSchema, ToolConfigSchema, PermissionModeSchema, SettingSourceSchema, LoopConfigSchema, ConfiguredFeedSchema, MAX_LOOP_TIMES, PERMISSION_MODE, SETTING_SOURCE, DEFAULT_SETTING_SOURCES, TOOL_MODE, DEFAULT_AVAILABLE_TOOLS, SUBAGENT_TOOL_NAME, AGENT_TYPE, } from "./schemas/agent.schema.js";
+export { SchedulerTimeSchema, DAY_OF_WEEK, DayOfWeekSchema, TimeModeSchema, TIME_MODE, } from "./schemas/scheduler.schema.js";
+export { createApiSuccessSchema, ApiErrorSchema, } from "./schemas/api-response.schema.js";
+export { SessionUsageSchema, PendingPermissionInfoSchema, AgentRuntimeStateSchema, AgentActivitySchema, AGENT_ACTIVITY_TYPE, AGENT_STATUS, } from "./schemas/agent-runtime-state.schema.js";
+export { ClientMessageSchema, ServerMessageSchema, SendMessageSchema, InjectMessageSchema, PermissionResponseWsSchema, AgentTextWsMessageSchema, AgentActivityWsMessageSchema, AgentResultWsMessageSchema, AgentStatusWsMessageSchema, AgentUpdatedWsMessageSchema, AgentUsageWsMessageSchema, PermissionRequestWsMessageSchema, PermissionCancelledWsMessageSchema, ErrorWsMessageSchema, AgentMessageWsMessageSchema, AgentToolProgressWsMessageSchema, TaskAddedWsMessageSchema, TaskUpdatedWsMessageSchema, TaskAssignedWsMessageSchema, TaskStateChangedWsMessageSchema, TaskDeletedWsMessageSchema, CircleCreatedWsMessageSchema, CircleUpdatedWsMessageSchema, CircleDeletedWsMessageSchema, RelationshipCreatedWsMessageSchema, RelationshipDeletedWsMessageSchema, CLIENT_MESSAGE_TYPE, SERVER_MESSAGE_TYPE, } from "./schemas/websocket.schema.js";
+export { PERMISSION_DECISION, PermissionRequestSchema, PermissionResponseSchema, } from "./schemas/permission.schema.js";
+export { AgentMessageSchema, AGENT_MESSAGE_ROLE, AGENT_MESSAGE_TYPE, } from "./schemas/agent-message.schema.js";
+export { ARTIFACT_TYPE, ARTIFACT_CONTENT_TYPE, ArtifactTypeSchema, ArtifactContentTypeSchema, ArtifactMetadataSchema, } from "./schemas/artifact.schema.js";
+export { AGENT_TASK_STATE, AGENT_TASK_SOURCE_TYPE, AgentTaskStateSchema, AgentTaskSourceSchema, AgentTaskItemSchema, AgentTaskDatabaseSchema, CreateTaskInputSchema, UpdateTaskInputSchema, UpdateTaskStateInputSchema, AssignTaskInputSchema, } from "./schemas/agent-task.schema.js";
+export { MCP_CONFIG_TYPE, McpServerConfigSchema, CreateMcpConfigInputSchema, UpdateMcpConfigInputSchema, } from "./schemas/mcp-config.schema.js";
+export { SensorInfoSchema } from "./schemas/sensor.schema.js";
+export { AddFeedInputSchema, DetectFeedsInputSchema, } from "./schemas/feed.schema.js";
+export { DiscordConfigSchema } from "./schemas/discord-config.schema.js";
+export { SuperCrowSettingsSchema, UpdateSuperCrowSettingsInputSchema, DashboardSettingsSchema, UpdateDashboardSettingsInputSchema, } from "./schemas/system-settings.schema.js";
+export { applyAgentOrder } from "./utils/apply-agent-order.js";
+export { MODEL_ALIASES, resolveModel } from "./utils/resolve-model.js";
+export { BASE_CIRCLE_ID, BASE_CIRCLE_NAME } from "./constants/system-circle.js";
+export { ENTITY_TYPE, RELATIONSHIP_TYPE, AgentCircleSchema, CreateAgentCircleInputSchema, UpdateAgentCircleInputSchema, EntityTypeSchema, RelationshipTypeSchema, RelationshipSchema, CreateRelationshipInputSchema, CircleMemberSchema, } from "./schemas/agent-circle.schema.js";
+export { CROW_SYSTEM_AGENT_ID, CROW_TASK_DISPATCHER_AGENT_ID } from "./constants/system-agent.js";
+export { MESSAGE_SOURCE_TYPE, MessageSourceSchema, } from "./schemas/message-source.schema.js";
+export { GraphNodeSchema, GraphEdgeSchema, GraphDataSchema, } from "./schemas/graph.schema.js";
+//# sourceMappingURL=index.js.map

package/dist/_shared/schemas/agent-circle.schema.js

@@ -0,0 +1,64 @@
+import { z } from "zod";
+/**
+ * Entity types used in relationship source/target fields.
+ */
+export const ENTITY_TYPE = {
+    AGENT: "AGENT",
+    AGENT_CIRCLE: "AGENT_CIRCLE",
+};
+/**
+ * Relationship types between entities.
+ * MEMBERSHIP means "source contains target as a member".
+ */
+export const RELATIONSHIP_TYPE = {
+    MEMBERSHIP: "MEMBERSHIP",
+};
+export const AgentCircleSchema = z.object({
+    /** Unique identifier - UUID for user-created circles, well-known string for system circles */
+    id: z.string().min(1),
+    /** Circle display name */
+    name: z.string().min(1).max(64),
+    /** Whether this is a built-in system circle (cannot be deleted) */
+    isSystemCircle: z.boolean().optional(),
+    /** Conventions or rules for the circle that agents should follow */
+    convention: z.string().optional(),
+    /** Display order for dashboard rendering (lower = first) */
+    displayOrder: z.number().optional(),
+    createdTimestamp: z.number(),
+    updatedTimestamp: z.number(),
+});
+export const CreateAgentCircleInputSchema = z.object({
+    name: z.string().min(1).max(64),
+    convention: z.string().optional(),
+    displayOrder: z.number().optional(),
+});
+export const UpdateAgentCircleInputSchema = z.object({
+    name: z.string().min(1).max(64).optional(),
+    convention: z.string().optional(),
+    displayOrder: z.number().optional(),
+});
+export const EntityTypeSchema = z.enum([ENTITY_TYPE.AGENT, ENTITY_TYPE.AGENT_CIRCLE]);
+export const RelationshipTypeSchema = z.enum([RELATIONSHIP_TYPE.MEMBERSHIP]);
+export const RelationshipSchema = z.object({
+    /** Unique identifier - UUID except for virtual relationship with system agents */
+    id: z.string().min(1),
+    sourceEntityId: z.string(),
+    sourceEntityType: EntityTypeSchema,
+    targetEntityId: z.string(),
+    targetEntityType: EntityTypeSchema,
+    relationshipType: RelationshipTypeSchema,
+    createdTimestamp: z.number(),
+});
+export const CreateRelationshipInputSchema = z.object({
+    sourceEntityId: z.string(),
+    sourceEntityType: EntityTypeSchema,
+    targetEntityId: z.string(),
+    targetEntityType: EntityTypeSchema,
+    relationshipType: RelationshipTypeSchema,
+});
+export const CircleMemberSchema = z.object({
+    relationshipId: z.string(),
+    entityId: z.string(),
+    entityType: EntityTypeSchema,
+});
+//# sourceMappingURL=agent-circle.schema.js.map

package/dist/_shared/schemas/agent-message.schema.js

@@ -0,0 +1,50 @@
+import { z } from "zod";
+export const AGENT_MESSAGE_ROLE = {
+    USER: "user",
+    AGENT: "agent",
+    SYSTEM: "system",
+};
+export const AGENT_MESSAGE_TYPE = {
+    TEXT: "TEXT",
+    THINKING: "THINKING",
+    TOOL_USE: "TOOL_USE",
+};
+/** Shared base fields for all agent messages */
+const AgentMessageBase = z.object({
+    /** Unique message identifier (derived from SDK SessionMessage uuid) */
+    id: z.string(),
+    /** Message content - user text, agent markdown response, or tool activity description */
+    content: z.string(),
+    /** Timestamp for ordering */
+    timestamp: z.number(),
+});
+/** User or agent text message */
+const TextMessageSchema = AgentMessageBase.extend({
+    role: z.enum([AGENT_MESSAGE_ROLE.USER, AGENT_MESSAGE_ROLE.AGENT]),
+    type: z.literal(AGENT_MESSAGE_TYPE.TEXT),
+});
+/** Agent thinking block (collapsed in UI by default) */
+const ThinkingMessageSchema = AgentMessageBase.extend({
+    role: z.literal(AGENT_MESSAGE_ROLE.AGENT),
+    type: z.literal(AGENT_MESSAGE_TYPE.THINKING),
+});
+/** Tool use activity (system-generated) */
+const ToolUseMessageSchema = AgentMessageBase.extend({
+    role: z.literal(AGENT_MESSAGE_ROLE.SYSTEM),
+    type: z.literal(AGENT_MESSAGE_TYPE.TOOL_USE),
+    /** Tool name - identifies which tool was used */
+    toolName: z.string(),
+    /** Raw tool input passed to the tool */
+    toolInput: z.record(z.string(), z.unknown()),
+});
+/**
+ * Agent message - the standard message data model for the conversation.
+ * Created exclusively by SessionManager from SDK SessionMessage data.
+ * Discriminated union on `type` enforces valid role/type combinations.
+ */
+export const AgentMessageSchema = z.discriminatedUnion("type", [
+    TextMessageSchema,
+    ThinkingMessageSchema,
+    ToolUseMessageSchema,
+]);
+//# sourceMappingURL=agent-message.schema.js.map

package/dist/_shared/schemas/agent-runtime-state.schema.js

@@ -0,0 +1,74 @@
+import { z } from "zod";
+import { MessageSourceSchema } from "./message-source.schema.js";
+export const AGENT_STATUS = {
+    IDLE: "idle",
+    ACTIVATING: "activating",
+    STREAMING: "streaming",
+    COMPACTING: "compacting",
+};
+export const AGENT_ACTIVITY_TYPE = {
+    GENERAL: "GENERAL",
+    QUERYSTART: "QUERYSTART",
+    TOOLUSE: "TOOLUSE",
+};
+export const AgentActivityCommonSchema = z.object({
+    id: z.string(),
+    timestamp: z.number(),
+});
+export const AgentQueryStartSchema = AgentActivityCommonSchema.extend({
+    type: z.literal(AGENT_ACTIVITY_TYPE.QUERYSTART),
+});
+export const AgentGeneralActivitySchema = AgentActivityCommonSchema.extend({
+    type: z.literal(AGENT_ACTIVITY_TYPE.GENERAL),
+    activity: z.string(),
+    description: z.string(),
+    subAgentId: z.string().optional(),
+});
+export const AgentToolUseActivitySchema = AgentActivityCommonSchema.extend({
+    type: z.literal(AGENT_ACTIVITY_TYPE.TOOLUSE),
+    toolName: z.string(),
+    description: z.string(),
+    input: z.unknown().optional(),
+    subAgentId: z.string().optional(),
+});
+export const AgentActivitySchema = z.discriminatedUnion("type", [
+    AgentGeneralActivitySchema,
+    AgentToolUseActivitySchema,
+    AgentQueryStartSchema,
+]);
+/**
+ * Session usage tracking - accumulated across queries in a session
+ */
+export const SessionUsageSchema = z.object({
+    inputTokens: z.number().default(0),
+    outputTokens: z.number().default(0),
+    totalCostUsd: z.number().default(0),
+    contextUsed: z.number().default(0),
+    contextTotal: z.number().default(0),
+});
+/**
+ * Pending permission request metadata - persisted on runtime state
+ * so the frontend can recover pending permissions on refresh.
+ */
+export const PendingPermissionInfoSchema = z.object({
+    toolUseId: z.string(),
+    toolName: z.string(),
+    input: z.record(z.string(), z.unknown()).optional(),
+    decisionReason: z.string().optional(),
+});
+/**
+ * Agent runtime state - maintained by the runtime manager per agent.
+ */
+export const AgentRuntimeStateSchema = z.object({
+    agentId: z.string(),
+    status: z
+        .enum([AGENT_STATUS.IDLE, AGENT_STATUS.ACTIVATING, AGENT_STATUS.STREAMING, AGENT_STATUS.COMPACTING])
+        .default(AGENT_STATUS.IDLE),
+    messageSource: MessageSourceSchema.optional(),
+    discordDmChannelId: z.string().optional(),
+    sessionId: z.string().optional(),
+    sessionUsage: SessionUsageSchema,
+    lastError: z.string().optional(),
+    pendingPermissions: z.array(PendingPermissionInfoSchema).optional(),
+});
+//# sourceMappingURL=agent-runtime-state.schema.js.map

package/dist/_shared/schemas/agent-task.schema.js

@@ -0,0 +1,85 @@
+import { z } from "zod";
+export const AGENT_TASK_STATE = {
+    OPEN: "OPEN",
+    ACTIVE: "ACTIVE",
+    INCOMPLETE: "INCOMPLETE",
+    COMPLETED: "COMPLETED",
+    CLOSED: "CLOSED",
+};
+export const AGENT_TASK_SOURCE_TYPE = {
+    AGENT: "AGENT",
+    USER: "USER",
+    LOOP: "LOOP",
+    REMINDER: "REMINDER",
+    SYSTEM: "SYSTEM",
+};
+const UserSourceSchema = z.object({
+    sourceType: z.literal(AGENT_TASK_SOURCE_TYPE.USER),
+});
+const AgentSourceSchema = z.object({
+    sourceType: z.literal(AGENT_TASK_SOURCE_TYPE.AGENT),
+    agentId: z.string(),
+});
+const LoopSourceSchema = z.object({
+    sourceType: z.literal(AGENT_TASK_SOURCE_TYPE.LOOP),
+});
+const ReminderSourceSchema = z.object({
+    sourceType: z.literal(AGENT_TASK_SOURCE_TYPE.REMINDER),
+});
+const SystemSourceSchema = z.object({
+    sourceType: z.literal(AGENT_TASK_SOURCE_TYPE.SYSTEM),
+});
+export const AgentTaskSourceSchema = z.discriminatedUnion("sourceType", [
+    UserSourceSchema,
+    AgentSourceSchema,
+    LoopSourceSchema,
+    ReminderSourceSchema,
+    SystemSourceSchema,
+]);
+export const AgentTaskStateSchema = z.enum([
+    AGENT_TASK_STATE.OPEN,
+    AGENT_TASK_STATE.ACTIVE,
+    AGENT_TASK_STATE.INCOMPLETE,
+    AGENT_TASK_STATE.COMPLETED,
+    AGENT_TASK_STATE.CLOSED,
+]);
+export const AgentTaskItemSchema = z.object({
+    id: z.string(),
+    parentTaskId: z.string().optional(),
+    state: AgentTaskStateSchema,
+    originateSource: AgentTaskSourceSchema,
+    dispatchSource: AgentTaskSourceSchema.optional(),
+    ownerSource: AgentTaskSourceSchema.optional(),
+    task: z.string(),
+    taskResult: z.string().optional(),
+    subTaskIds: z.array(z.string()).optional(),
+    createdTimestamp: z.number(),
+    updatedTimestamp: z.number(),
+});
+export const AgentTaskDatabaseSchema = z.object({
+    version: z.number(),
+    tasks: z.array(AgentTaskItemSchema),
+});
+/** Input for creating a new task. Optionally assign an owner at creation time. */
+export const CreateTaskInputSchema = z.object({
+    task: z.string().min(1, "Task description is required"),
+    ownerSource: AgentTaskSourceSchema.optional(),
+    parentTaskId: z.string().optional(),
+});
+/** Input for updating task content (only allowed when state is OPEN). */
+export const UpdateTaskInputSchema = z.object({
+    task: z.string().min(1, "Task description is required"),
+});
+/**
+ * Input for transitioning a task to a new state via REST.
+ * Only includes states reachable by user action. OPEN is the initial
+ * state (not a valid target), and ACTIVE is system-driven by the runtime manager.
+ */
+export const UpdateTaskStateInputSchema = z.object({
+    state: z.enum([AGENT_TASK_STATE.INCOMPLETE, AGENT_TASK_STATE.COMPLETED, AGENT_TASK_STATE.CLOSED]),
+});
+/** Input for assigning a task. Accepts the owner source (who will handle the task). */
+export const AssignTaskInputSchema = z.object({
+    ownerSource: AgentTaskSourceSchema,
+});
+//# sourceMappingURL=agent-task.schema.js.map