@spencerbeggs/claude-coordinator-core 0.1.0 → 0.1.1

package/index.d.ts

@@ -1,242 +1,334 @@
-/**
- * \@spencerbeggs/claude-coordinator-core
- *
- * Core schemas and types for the Claude Coordinator system.
- * Provides Zod schemas for validation and TypeScript types for
- * communication between Claude Code instances.
- *
- * @packageDocumentation
- */
-
-import { z } from 'zod';
-
-export declare type Agent = z.infer<typeof AgentSchema>;
-
-export declare type AgentRole = z.infer<typeof AgentRoleSchema>;
-
-/**
- * Role of an agent in the coordination session
- */
-export declare const AgentRoleSchema: z.ZodEnum<{
-    source: "source";
-    target: "target";
-}>;
-
-/**
- * Schema for a connected agent in the coordination session
- */
-export declare const AgentSchema: z.ZodObject<{
-    id: z.ZodString;
-    role: z.ZodEnum<{
-        source: "source";
-        target: "target";
-    }>;
-    name: z.ZodString;
-    repoPath: z.ZodString;
-    connectedAt: z.ZodCoercedDate<unknown>;
-}, z.core.$strip>;
-
-export declare type AnswerEvent = z.infer<typeof AnswerEventSchema>;
-
-/**
- * Event emitted when a question is answered
- */
-export declare const AnswerEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"answer">;
-    question: z.ZodObject<{
-        id: z.ZodString;
-        question: z.ZodString;
-        from: z.ZodString;
-        to: z.ZodOptional<z.ZodString>;
-        answer: z.ZodOptional<z.ZodString>;
-        answeredBy: z.ZodOptional<z.ZodString>;
-        status: z.ZodEnum<{
-            answered: "answered";
-            pending: "pending";
-        }>;
-        createdAt: z.ZodCoercedDate<unknown>;
-        answeredAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-
-export declare type AnswerInput = z.infer<typeof AnswerInputSchema>;
-
-/**
- * Input schema for answering a question
- */
-export declare const AnswerInputSchema: z.ZodObject<{
-    questionId: z.ZodString;
-    answer: z.ZodString;
-}, z.core.$strip>;
-
-export declare type AskInput = z.infer<typeof AskInputSchema>;
-
-/**
- * Input schema for asking a question
- */
-export declare const AskInputSchema: z.ZodObject<{
-    question: z.ZodString;
-    to: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-
-export declare type ContextEntry = z.infer<typeof ContextEntrySchema>;
-
-/**
- * Schema for a shared context entry
- */
-export declare const ContextEntrySchema: z.ZodObject<{
-    id: z.ZodString;
-    key: z.ZodString;
-    value: z.ZodString;
-    tags: z.ZodArray<z.ZodString>;
-    createdBy: z.ZodString;
-    createdAt: z.ZodCoercedDate<unknown>;
-    updatedAt: z.ZodCoercedDate<unknown>;
-}, z.core.$strip>;
-
-export declare type Decision = z.infer<typeof DecisionSchema>;
-
-/**
- * Schema for a logged decision
- */
-export declare const DecisionSchema: z.ZodObject<{
-    id: z.ZodString;
-    decision: z.ZodString;
-    rationale: z.ZodOptional<z.ZodString>;
-    by: z.ZodString;
-    createdAt: z.ZodCoercedDate<unknown>;
-}, z.core.$strip>;
-
-export declare const DEFAULT_HOST: string;
-
-export declare const DEFAULT_PORT: number;
-
-export declare const DEFAULT_URL: string;
-
-export declare type GetContextInput = z.infer<typeof GetContextInputSchema>;
-
-/**
- * Input schema for retrieving a context entry by key
- */
-export declare const GetContextInputSchema: z.ZodObject<{
-    key: z.ZodString;
-}, z.core.$strip>;
-
-export declare type JoinInput = z.infer<typeof JoinInputSchema>;
-
-/**
- * Input schema for joining a coordination session
- */
-export declare const JoinInputSchema: z.ZodObject<{
-    name: z.ZodString;
-    role: z.ZodEnum<{
-        source: "source";
-        target: "target";
-    }>;
-    repoPath: z.ZodString;
-}, z.core.$strip>;
-
-export declare type JoinResult = z.infer<typeof JoinResultSchema>;
-
-/**
- * Result of joining a coordination session
- */
-export declare const JoinResultSchema: z.ZodObject<{
-    agent: z.ZodObject<{
-        id: z.ZodString;
-        role: z.ZodEnum<{
-            source: "source";
-            target: "target";
-        }>;
-        name: z.ZodString;
-        repoPath: z.ZodString;
-        connectedAt: z.ZodCoercedDate<unknown>;
-    }, z.core.$strip>;
-    sessionId: z.ZodString;
-}, z.core.$strip>;
-
-export declare type ListContextInput = z.infer<typeof ListContextInputSchema>;
-
-/**
- * Input schema for listing context entries with optional filters
- */
-export declare const ListContextInputSchema: z.ZodObject<{
-    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    createdBy: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-
-export declare type LogDecisionInput = z.infer<typeof LogDecisionInputSchema>;
-
-/**
- * Input schema for logging a decision
- */
-export declare const LogDecisionInputSchema: z.ZodObject<{
-    decision: z.ZodString;
-    rationale: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-
-export declare type Question = z.infer<typeof QuestionSchema>;
-
-export declare type QuestionEvent = z.infer<typeof QuestionEventSchema>;
-
-/**
- * Event emitted when a question is asked
- */
-export declare const QuestionEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"question">;
-    question: z.ZodObject<{
-        id: z.ZodString;
-        question: z.ZodString;
-        from: z.ZodString;
-        to: z.ZodOptional<z.ZodString>;
-        answer: z.ZodOptional<z.ZodString>;
-        answeredBy: z.ZodOptional<z.ZodString>;
-        status: z.ZodEnum<{
-            answered: "answered";
-            pending: "pending";
-        }>;
-        createdAt: z.ZodCoercedDate<unknown>;
-        answeredAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-
-/**
- * Schema for a question between agents
- */
-export declare const QuestionSchema: z.ZodObject<{
-    id: z.ZodString;
-    question: z.ZodString;
-    from: z.ZodString;
-    to: z.ZodOptional<z.ZodString>;
-    answer: z.ZodOptional<z.ZodString>;
-    answeredBy: z.ZodOptional<z.ZodString>;
-    status: z.ZodEnum<{
-        answered: "answered";
-        pending: "pending";
-    }>;
-    createdAt: z.ZodCoercedDate<unknown>;
-    answeredAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
-}, z.core.$strip>;
-
-export declare type QuestionStatus = z.infer<typeof QuestionStatusSchema>;
-
-/**
- * Status of a question
- */
-export declare const QuestionStatusSchema: z.ZodEnum<{
-    answered: "answered";
-    pending: "pending";
-}>;
-
-export declare type ShareContextInput = z.infer<typeof ShareContextInputSchema>;
-
-/**
- * Input schema for sharing a context entry
- */
-export declare const ShareContextInputSchema: z.ZodObject<{
-    key: z.ZodString;
-    value: z.ZodString;
-    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
-
-export { }
+import { z } from "zod";
+//#region src/schemas/agent.d.ts
+/**
+ * Role of an agent in the coordination session
+ *
+ * @public
+ */
+declare const AgentRoleSchema: z.ZodEnum<{
+  source: "source";
+  target: "target";
+}>;
+/**
+ * Role of an agent in the coordination session
+ *
+ * @public
+ */
+type AgentRole = z.infer<typeof AgentRoleSchema>;
+/**
+ * Schema for a connected agent in the coordination session
+ *
+ * @public
+ */
+declare const AgentSchema: z.ZodObject<{
+  id: z.ZodString;
+  role: z.ZodEnum<{
+    source: "source";
+    target: "target";
+  }>;
+  name: z.ZodString;
+  repoPath: z.ZodString;
+  connectedAt: z.ZodCoercedDate<unknown>;
+}, z.core.$strip>;
+/**
+ * A connected agent in the coordination session
+ *
+ * @public
+ */
+type Agent = z.infer<typeof AgentSchema>;
+/**
+ * Input schema for joining a coordination session
+ *
+ * @public
+ */
+declare const JoinInputSchema: z.ZodObject<{
+  name: z.ZodString;
+  role: z.ZodEnum<{
+    source: "source";
+    target: "target";
+  }>;
+  repoPath: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Input for joining a coordination session
+ *
+ * @public
+ */
+type JoinInput = z.infer<typeof JoinInputSchema>;
+/**
+ * Result of joining a coordination session
+ *
+ * @public
+ */
+declare const JoinResultSchema: z.ZodObject<{
+  agent: z.ZodObject<{
+    id: z.ZodString;
+    role: z.ZodEnum<{
+      source: "source";
+      target: "target";
+    }>;
+    name: z.ZodString;
+    repoPath: z.ZodString;
+    connectedAt: z.ZodCoercedDate<unknown>;
+  }, z.core.$strip>;
+  sessionId: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Result of joining a coordination session
+ *
+ * @public
+ */
+type JoinResult = z.infer<typeof JoinResultSchema>;
+//#endregion
+//#region src/schemas/context.d.ts
+/**
+ * Schema for a shared context entry
+ *
+ * @public
+ */
+declare const ContextEntrySchema: z.ZodObject<{
+  id: z.ZodString;
+  key: z.ZodString;
+  value: z.ZodString;
+  tags: z.ZodArray<z.ZodString>;
+  createdBy: z.ZodString;
+  createdAt: z.ZodCoercedDate<unknown>;
+  updatedAt: z.ZodCoercedDate<unknown>;
+}, z.core.$strip>;
+/**
+ * A shared context entry
+ *
+ * @public
+ */
+type ContextEntry = z.infer<typeof ContextEntrySchema>;
+/**
+ * Input schema for sharing a context entry
+ *
+ * @public
+ */
+declare const ShareContextInputSchema: z.ZodObject<{
+  key: z.ZodString;
+  value: z.ZodString;
+  tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * Input for sharing a context entry
+ *
+ * @public
+ */
+type ShareContextInput = z.infer<typeof ShareContextInputSchema>;
+/**
+ * Input schema for retrieving a context entry by key
+ *
+ * @public
+ */
+declare const GetContextInputSchema: z.ZodObject<{
+  key: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Input for retrieving a context entry by key
+ *
+ * @public
+ */
+type GetContextInput = z.infer<typeof GetContextInputSchema>;
+/**
+ * Input schema for listing context entries with optional filters
+ *
+ * @public
+ */
+declare const ListContextInputSchema: z.ZodObject<{
+  tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  createdBy: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Input for listing context entries with optional filters
+ *
+ * @public
+ */
+type ListContextInput = z.infer<typeof ListContextInputSchema>;
+//#endregion
+//#region src/schemas/decision.d.ts
+/**
+ * Schema for a logged decision
+ *
+ * @public
+ */
+declare const DecisionSchema: z.ZodObject<{
+  id: z.ZodString;
+  decision: z.ZodString;
+  rationale: z.ZodOptional<z.ZodString>;
+  by: z.ZodString;
+  createdAt: z.ZodCoercedDate<unknown>;
+}, z.core.$strip>;
+/**
+ * A logged decision
+ *
+ * @public
+ */
+type Decision = z.infer<typeof DecisionSchema>;
+/**
+ * Input schema for logging a decision
+ *
+ * @public
+ */
+declare const LogDecisionInputSchema: z.ZodObject<{
+  decision: z.ZodString;
+  rationale: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Input for logging a decision
+ *
+ * @public
+ */
+type LogDecisionInput = z.infer<typeof LogDecisionInputSchema>;
+//#endregion
+//#region src/schemas/question.d.ts
+/**
+ * Status of a question
+ *
+ * @public
+ */
+declare const QuestionStatusSchema: z.ZodEnum<{
+  answered: "answered";
+  pending: "pending";
+}>;
+/**
+ * Status of a question
+ *
+ * @public
+ */
+type QuestionStatus = z.infer<typeof QuestionStatusSchema>;
+/**
+ * Schema for a question between agents
+ *
+ * @public
+ */
+declare const QuestionSchema: z.ZodObject<{
+  id: z.ZodString;
+  question: z.ZodString;
+  from: z.ZodString;
+  to: z.ZodOptional<z.ZodString>;
+  answer: z.ZodOptional<z.ZodString>;
+  answeredBy: z.ZodOptional<z.ZodString>;
+  status: z.ZodEnum<{
+    answered: "answered";
+    pending: "pending";
+  }>;
+  createdAt: z.ZodCoercedDate<unknown>;
+  answeredAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+}, z.core.$strip>;
+/**
+ * A question between agents
+ *
+ * @public
+ */
+type Question = z.infer<typeof QuestionSchema>;
+/**
+ * Input schema for asking a question
+ *
+ * @public
+ */
+declare const AskInputSchema: z.ZodObject<{
+  question: z.ZodString;
+  to: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Input for asking a question
+ *
+ * @public
+ */
+type AskInput = z.infer<typeof AskInputSchema>;
+/**
+ * Input schema for answering a question
+ *
+ * @public
+ */
+declare const AnswerInputSchema: z.ZodObject<{
+  questionId: z.ZodString;
+  answer: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Input for answering a question
+ *
+ * @public
+ */
+type AnswerInput = z.infer<typeof AnswerInputSchema>;
+/**
+ * Event emitted when a question is asked
+ *
+ * @public
+ */
+declare const QuestionEventSchema: z.ZodObject<{
+  type: z.ZodLiteral<"question">;
+  question: z.ZodObject<{
+    id: z.ZodString;
+    question: z.ZodString;
+    from: z.ZodString;
+    to: z.ZodOptional<z.ZodString>;
+    answer: z.ZodOptional<z.ZodString>;
+    answeredBy: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+      answered: "answered";
+      pending: "pending";
+    }>;
+    createdAt: z.ZodCoercedDate<unknown>;
+    answeredAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * Event emitted when a question is asked
+ *
+ * @public
+ */
+type QuestionEvent = z.infer<typeof QuestionEventSchema>;
+/**
+ * Event emitted when a question is answered
+ *
+ * @public
+ */
+declare const AnswerEventSchema: z.ZodObject<{
+  type: z.ZodLiteral<"answer">;
+  question: z.ZodObject<{
+    id: z.ZodString;
+    question: z.ZodString;
+    from: z.ZodString;
+    to: z.ZodOptional<z.ZodString>;
+    answer: z.ZodOptional<z.ZodString>;
+    answeredBy: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+      answered: "answered";
+      pending: "pending";
+    }>;
+    createdAt: z.ZodCoercedDate<unknown>;
+    answeredAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * Event emitted when a question is answered
+ *
+ * @public
+ */
+type AnswerEvent = z.infer<typeof AnswerEventSchema>;
+//#endregion
+//#region src/index.d.ts
+/**
+ * Default port for the coordinator WebSocket server
+ *
+ * @public
+ */
+declare const DEFAULT_PORT: number;
+/**
+ * Default host for the coordinator WebSocket server
+ *
+ * @public
+ */
+declare const DEFAULT_HOST: string;
+/**
+ * Default WebSocket URL for the coordinator server
+ *
+ * @public
+ */
+declare const DEFAULT_URL: string;
+//#endregion
+export { type Agent, type AgentRole, AgentRoleSchema, AgentSchema, type AnswerEvent, AnswerEventSchema, type AnswerInput, AnswerInputSchema, type AskInput, AskInputSchema, type ContextEntry, ContextEntrySchema, DEFAULT_HOST, DEFAULT_PORT, DEFAULT_URL, type Decision, DecisionSchema, type GetContextInput, GetContextInputSchema, type JoinInput, JoinInputSchema, type JoinResult, JoinResultSchema, type ListContextInput, ListContextInputSchema, type LogDecisionInput, LogDecisionInputSchema, type Question, type QuestionEvent, QuestionEventSchema, QuestionSchema, type QuestionStatus, QuestionStatusSchema, type ShareContextInput, ShareContextInputSchema };
+//# sourceMappingURL=index.d.ts.map

package/index.js

@@ -1,88 +1,27 @@
-import { z } from "zod";
-const AgentRoleSchema = z["enum"]([
-    "source",
-    "target"
-]).describe("The role of the agent: 'source' provides knowledge, 'target' receives knowledge");
-const AgentSchema = z.object({
-    id: z.string().uuid().describe("Unique identifier for the agent"),
-    role: AgentRoleSchema,
-    name: z.string().min(1).describe("Human-readable name for the agent"),
-    repoPath: z.string().min(1).describe("Path to the repository this agent is working in"),
-    connectedAt: z.coerce.date().describe("Timestamp when the agent connected")
-}).describe("A connected agent in the coordination session");
-const JoinInputSchema = z.object({
-    name: z.string().min(1).describe("Human-readable name for the agent"),
-    role: AgentRoleSchema,
-    repoPath: z.string().min(1).describe("Path to the repository this agent is working in")
-}).describe("Input for joining a coordination session");
-const JoinResultSchema = z.object({
-    agent: AgentSchema,
-    sessionId: z.string().uuid().describe("Unique identifier for the session")
-}).describe("Result of joining a coordination session");
-const ContextEntrySchema = z.object({
-    id: z.string().uuid().describe("Unique identifier for this context entry"),
-    key: z.string().min(1).describe("Key to identify this context entry"),
-    value: z.string().describe("The context value/content"),
-    tags: z.array(z.string()).describe("Tags for categorizing context"),
-    createdBy: z.string().uuid().describe("ID of the agent that created this entry"),
-    createdAt: z.coerce.date().describe("Timestamp when the entry was created"),
-    updatedAt: z.coerce.date().describe("Timestamp when the entry was last updated")
-}).describe("A shared context entry");
-const ShareContextInputSchema = z.object({
-    key: z.string().min(1).describe("Key to identify this context entry"),
-    value: z.string().describe("The context value/content to share"),
-    tags: z.array(z.string()).optional().describe("Optional tags for categorizing context")
-}).describe("Input for sharing a context entry");
-const GetContextInputSchema = z.object({
-    key: z.string().min(1).describe("Key of the context entry to retrieve")
-}).describe("Input for retrieving a context entry by key");
-const ListContextInputSchema = z.object({
-    tags: z.array(z.string()).optional().describe("Filter by tags (entries must have all specified tags)"),
-    createdBy: z.string().uuid().optional().describe("Filter by creator agent ID")
-}).describe("Input for listing context entries with optional filters");
-const DecisionSchema = z.object({
-    id: z.string().uuid().describe("Unique identifier for this decision"),
-    decision: z.string().min(1).describe("The decision that was made"),
-    rationale: z.string().optional().describe("Explanation for why this decision was made"),
-    by: z.string().uuid().describe("ID of the agent that made this decision"),
-    createdAt: z.coerce.date().describe("Timestamp when the decision was logged")
-}).describe("A logged decision");
-const LogDecisionInputSchema = z.object({
-    decision: z.string().min(1).describe("The decision that was made"),
-    rationale: z.string().optional().describe("Explanation for why this decision was made")
-}).describe("Input for logging a decision");
-const QuestionStatusSchema = z["enum"]([
-    "pending",
-    "answered"
-]).describe("Status of the question");
-const QuestionSchema = z.object({
-    id: z.string().uuid().describe("Unique identifier for this question"),
-    question: z.string().min(1).describe("The question being asked"),
-    from: z.string().uuid().describe("ID of the agent asking the question"),
-    to: z.string().uuid().optional().describe("ID of a specific agent to answer (optional)"),
-    answer: z.string().optional().describe("The answer to the question"),
-    answeredBy: z.string().uuid().optional().describe("ID of the agent that answered"),
-    status: QuestionStatusSchema,
-    createdAt: z.coerce.date().describe("Timestamp when the question was asked"),
-    answeredAt: z.coerce.date().optional().describe("Timestamp when the question was answered")
-}).describe("A question between agents");
-const AskInputSchema = z.object({
-    question: z.string().min(1).describe("The question to ask"),
-    to: z.string().uuid().optional().describe("ID of a specific agent to answer (optional)")
-}).describe("Input for asking a question");
-const AnswerInputSchema = z.object({
-    questionId: z.string().uuid().describe("ID of the question to answer"),
-    answer: z.string().min(1).describe("The answer to the question")
-}).describe("Input for answering a question");
-const QuestionEventSchema = z.object({
-    type: z.literal("question"),
-    question: QuestionSchema
-}).describe("Event emitted when a question is asked");
-const AnswerEventSchema = z.object({
-    type: z.literal("answer"),
-    question: QuestionSchema
-}).describe("Event emitted when a question is answered");
+import { AgentRoleSchema, AgentSchema, JoinInputSchema, JoinResultSchema } from "./schemas/agent.js";
+import { ContextEntrySchema, GetContextInputSchema, ListContextInputSchema, ShareContextInputSchema } from "./schemas/context.js";
+import { DecisionSchema, LogDecisionInputSchema } from "./schemas/decision.js";
+import { AnswerEventSchema, AnswerInputSchema, AskInputSchema, QuestionEventSchema, QuestionSchema, QuestionStatusSchema } from "./schemas/question.js";
+
+//#region src/index.ts
+/**
+* Default port for the coordinator WebSocket server
+*
+* @public
+*/
 const DEFAULT_PORT = 3030;
+/**
+* Default host for the coordinator WebSocket server
+*
+* @public
+*/
 const DEFAULT_HOST = "localhost";
+/**
+* Default WebSocket URL for the coordinator server
+*
+* @public
+*/
 const DEFAULT_URL = `ws://${DEFAULT_HOST}:${DEFAULT_PORT}`;
-export { AgentRoleSchema, AgentSchema, AnswerEventSchema, AnswerInputSchema, AskInputSchema, ContextEntrySchema, DEFAULT_HOST, DEFAULT_PORT, DEFAULT_URL, DecisionSchema, GetContextInputSchema, JoinInputSchema, JoinResultSchema, ListContextInputSchema, LogDecisionInputSchema, QuestionEventSchema, QuestionSchema, QuestionStatusSchema, ShareContextInputSchema };
+
+//#endregion
+export { AgentRoleSchema, AgentSchema, AnswerEventSchema, AnswerInputSchema, AskInputSchema, ContextEntrySchema, DEFAULT_HOST, DEFAULT_PORT, DEFAULT_URL, DecisionSchema, GetContextInputSchema, JoinInputSchema, JoinResultSchema, ListContextInputSchema, LogDecisionInputSchema, QuestionEventSchema, QuestionSchema, QuestionStatusSchema, ShareContextInputSchema };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@spencerbeggs/claude-coordinator-core",
-	"version": "0.1.0",
+	"version": "0.1.1",
 	"private": false,
 	"description": "Core schemas and types for Claude Coordinator",
 	"keywords": [
@@ -20,24 +20,20 @@
 		"email": "spencer@beggs.codes",
 		"url": "https://spencerbeg.gs"
 	},
+	"sideEffects": false,
 	"type": "module",
 	"exports": {
 		".": {
 			"types": "./index.d.ts",
-			"import": "./index.js"
-		}
+			"import": "./index.js",
+			"default": "./index.js"
+		},
+		"./package.json": "./package.json"
 	},
 	"dependencies": {
-		"zod": "^4.3.5"
+		"zod": "^4.5.4"
 	},
 	"engines": {
-		"node": ">=20.0.0"
-	},
-	"files": [
-		"LICENSE",
-		"README.md",
-		"index.d.ts",
-		"index.js",
-		"package.json"
-	]
-}
+		"node": ">=24.11.0"
+	}
+}

package/schemas/agent.js

@@ -0,0 +1,43 @@
+import { z } from "zod";
+
+//#region src/schemas/agent.ts
+/**
+* Role of an agent in the coordination session
+*
+* @public
+*/
+const AgentRoleSchema = z.enum(["source", "target"]).describe("The role of the agent: 'source' provides knowledge, 'target' receives knowledge");
+/**
+* Schema for a connected agent in the coordination session
+*
+* @public
+*/
+const AgentSchema = z.object({
+	id: z.string().uuid().describe("Unique identifier for the agent"),
+	role: AgentRoleSchema,
+	name: z.string().min(1).describe("Human-readable name for the agent"),
+	repoPath: z.string().min(1).describe("Path to the repository this agent is working in"),
+	connectedAt: z.coerce.date().describe("Timestamp when the agent connected")
+}).describe("A connected agent in the coordination session");
+/**
+* Input schema for joining a coordination session
+*
+* @public
+*/
+const JoinInputSchema = z.object({
+	name: z.string().min(1).describe("Human-readable name for the agent"),
+	role: AgentRoleSchema,
+	repoPath: z.string().min(1).describe("Path to the repository this agent is working in")
+}).describe("Input for joining a coordination session");
+/**
+* Result of joining a coordination session
+*
+* @public
+*/
+const JoinResultSchema = z.object({
+	agent: AgentSchema,
+	sessionId: z.string().uuid().describe("Unique identifier for the session")
+}).describe("Result of joining a coordination session");
+
+//#endregion
+export { AgentRoleSchema, AgentSchema, JoinInputSchema, JoinResultSchema };

package/schemas/context.js

@@ -0,0 +1,45 @@
+import { z } from "zod";
+
+//#region src/schemas/context.ts
+/**
+* Schema for a shared context entry
+*
+* @public
+*/
+const ContextEntrySchema = z.object({
+	id: z.string().uuid().describe("Unique identifier for this context entry"),
+	key: z.string().min(1).describe("Key to identify this context entry"),
+	value: z.string().describe("The context value/content"),
+	tags: z.array(z.string()).describe("Tags for categorizing context"),
+	createdBy: z.string().uuid().describe("ID of the agent that created this entry"),
+	createdAt: z.coerce.date().describe("Timestamp when the entry was created"),
+	updatedAt: z.coerce.date().describe("Timestamp when the entry was last updated")
+}).describe("A shared context entry");
+/**
+* Input schema for sharing a context entry
+*
+* @public
+*/
+const ShareContextInputSchema = z.object({
+	key: z.string().min(1).describe("Key to identify this context entry"),
+	value: z.string().describe("The context value/content to share"),
+	tags: z.array(z.string()).optional().describe("Optional tags for categorizing context")
+}).describe("Input for sharing a context entry");
+/**
+* Input schema for retrieving a context entry by key
+*
+* @public
+*/
+const GetContextInputSchema = z.object({ key: z.string().min(1).describe("Key of the context entry to retrieve") }).describe("Input for retrieving a context entry by key");
+/**
+* Input schema for listing context entries with optional filters
+*
+* @public
+*/
+const ListContextInputSchema = z.object({
+	tags: z.array(z.string()).optional().describe("Filter by tags (entries must have all specified tags)"),
+	createdBy: z.string().uuid().optional().describe("Filter by creator agent ID")
+}).describe("Input for listing context entries with optional filters");
+
+//#endregion
+export { ContextEntrySchema, GetContextInputSchema, ListContextInputSchema, ShareContextInputSchema };

package/schemas/decision.js

@@ -0,0 +1,27 @@
+import { z } from "zod";
+
+//#region src/schemas/decision.ts
+/**
+* Schema for a logged decision
+*
+* @public
+*/
+const DecisionSchema = z.object({
+	id: z.string().uuid().describe("Unique identifier for this decision"),
+	decision: z.string().min(1).describe("The decision that was made"),
+	rationale: z.string().optional().describe("Explanation for why this decision was made"),
+	by: z.string().uuid().describe("ID of the agent that made this decision"),
+	createdAt: z.coerce.date().describe("Timestamp when the decision was logged")
+}).describe("A logged decision");
+/**
+* Input schema for logging a decision
+*
+* @public
+*/
+const LogDecisionInputSchema = z.object({
+	decision: z.string().min(1).describe("The decision that was made"),
+	rationale: z.string().optional().describe("Explanation for why this decision was made")
+}).describe("Input for logging a decision");
+
+//#endregion
+export { DecisionSchema, LogDecisionInputSchema };

package/schemas/question.js

@@ -0,0 +1,64 @@
+import { z } from "zod";
+
+//#region src/schemas/question.ts
+/**
+* Status of a question
+*
+* @public
+*/
+const QuestionStatusSchema = z.enum(["pending", "answered"]).describe("Status of the question");
+/**
+* Schema for a question between agents
+*
+* @public
+*/
+const QuestionSchema = z.object({
+	id: z.string().uuid().describe("Unique identifier for this question"),
+	question: z.string().min(1).describe("The question being asked"),
+	from: z.string().uuid().describe("ID of the agent asking the question"),
+	to: z.string().uuid().optional().describe("ID of a specific agent to answer (optional)"),
+	answer: z.string().optional().describe("The answer to the question"),
+	answeredBy: z.string().uuid().optional().describe("ID of the agent that answered"),
+	status: QuestionStatusSchema,
+	createdAt: z.coerce.date().describe("Timestamp when the question was asked"),
+	answeredAt: z.coerce.date().optional().describe("Timestamp when the question was answered")
+}).describe("A question between agents");
+/**
+* Input schema for asking a question
+*
+* @public
+*/
+const AskInputSchema = z.object({
+	question: z.string().min(1).describe("The question to ask"),
+	to: z.string().uuid().optional().describe("ID of a specific agent to answer (optional)")
+}).describe("Input for asking a question");
+/**
+* Input schema for answering a question
+*
+* @public
+*/
+const AnswerInputSchema = z.object({
+	questionId: z.string().uuid().describe("ID of the question to answer"),
+	answer: z.string().min(1).describe("The answer to the question")
+}).describe("Input for answering a question");
+/**
+* Event emitted when a question is asked
+*
+* @public
+*/
+const QuestionEventSchema = z.object({
+	type: z.literal("question"),
+	question: QuestionSchema
+}).describe("Event emitted when a question is asked");
+/**
+* Event emitted when a question is answered
+*
+* @public
+*/
+const AnswerEventSchema = z.object({
+	type: z.literal("answer"),
+	question: QuestionSchema
+}).describe("Event emitted when a question is answered");
+
+//#endregion
+export { AnswerEventSchema, AnswerInputSchema, AskInputSchema, QuestionEventSchema, QuestionSchema, QuestionStatusSchema };

package/tsdoc-metadata.json

@@ -0,0 +1,11 @@
+// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
+// It should be published with your NPM package.  It should not be tracked by Git.
+{
+  "tsdocVersion": "0.12",
+  "toolPackages": [
+    {
+      "packageName": "@microsoft/api-extractor",
+      "packageVersion": "7.59.0"
+    }
+  ]
+}