@codeworksh/cli 0.5.0-canary.69.1.g5be1ef81 → 0.5.0-canary.71.1.g8233e4eb

package/{error-BMI81XvR.mjs → error-CSeYCa9R.mjs}

@@ -1,6 +1,6 @@
 import { Deferred, Duration, Effect, Layer, Predicate, Schema, Stream } from "effect";
 import { Model } from "@codeworksh/aikit";
-import { Control, Event, EventList, EventSchema, Location, ModelCatalog, Plugin, Project, PromptSchema, Runner, Sandbox, SandboxError, Session, SessionStore, Settings, optional } from "@codeworksh/harness/effect";
+import { Control, Event, EventList, EventSchema, Location, ModelCatalog, Plugin, Project, PromptSchema, Runner, Sandbox, SandboxError, Session, SessionStore, Settings, ThreadSchema, ThreadStore, optional } from "@codeworksh/harness/effect";
 import { SandboxProvider } from "@codeworksh/harness/sandbox";
 import { NodeSocket } from "@effect/platform-node";
 import { Rpc, RpcClient, RpcGroup, RpcSerialization } from "effect/rpc";
@@ -22,6 +22,8 @@ const EventEnvelope = Schema.Struct({
 	metadata: optional(Schema.Record(Schema.String, Schema.String)),
 	data: Schema.Unknown
 });
+/** Whether an event belongs to a thread: every thread-scoped event names its `threadId`. */
+const ofThread = (threadId) => (event) => Predicate.hasProperty(event.data, "threadId") && event.data.threadId === threadId;
 var UnknownEventTypeError = class extends Schema.TaggedError()("UnknownEventTypeError", { type: Schema.String }) {};
 /** The transport's own readiness frame; it has no meaning inside the harness. */
 const Connected = EventSchema.define({
@@ -135,9 +137,9 @@ const SandboxInfo = Schema.Struct({
 	createdAt: Schema.DateFromString,
 	updatedAt: Schema.DateFromString
 });
+/** The container: where its threads run by default, and which host project it reads. */
 const SessionInfo = Schema.Struct({
 	id: Session.SessionSchema.ID,
-	title: Schema.String,
 	directory: Session.AbsolutePath,
 	/** The host directory this session is anchored to. Absent when it has none. */
 	hostDir: optional(Session.AbsolutePath),
@@ -147,22 +149,70 @@ const SessionInfo = Schema.Struct({
 		id: Schema.String,
 		name: Schema.String
 	})),
+	/** Last activity in any of its threads, epoch milliseconds. */
+	updatedAt: Schema.Finite,
+	/** Where unaddressed prompts go. */
+	mainThreadId: ThreadSchema.ID
+});
+const ThreadOrigin = Schema.Union([
+	Schema.Struct({ kind: Schema.Literal("main") }),
+	Schema.Struct({
+		kind: Schema.Literal("fork"),
+		threadId: Schema.String,
+		entryId: Schema.String
+	}),
+	Schema.Struct({
+		kind: Schema.Literal("subagent"),
+		threadId: Schema.String,
+		callId: Schema.String,
+		entryId: optional(Schema.String)
+	})
+]);
+/** Billed usage of a thread's own entries; what it inherits through a fork point counts for its source. */
+const ThreadUsage = Schema.Struct({
+	/** Total cost in US dollars, from the catalog's prices. */
+	cost: Schema.Finite,
+	input: Schema.Int,
+	output: Schema.Int,
+	cacheRead: Schema.Int,
+	cacheWrite: Schema.Int
+});
+/** One linear transcript of a session, with the session embedded. */
+const ThreadInfo = Schema.Struct({
+	id: ThreadSchema.ID,
+	origin: ThreadOrigin,
+	/** Absent until its first own prompt; clients show a fork's source title until then. */
+	title: optional(Schema.String),
 	/** Last activity, epoch milliseconds. */
 	updatedAt: Schema.Finite,
-	/** The model chosen for this session; absent when settings decide. */
+	/** The model chosen for this thread; absent when settings decide. */
 	model: optional(Schema.Struct({
 		provider: Schema.String,
 		id: Schema.String
 	})),
-	/** The thinking level chosen for this session; absent when settings decide. */
+	/** The thinking level chosen for this thread; absent when settings decide. */
 	thinkingLevel: optional(Schema.Enum(Model.ThinkingLevelEnum)),
+	/** Where it runs instead of the session's space and directory. */
+	placement: optional(Schema.Struct({
+		spaceId: Schema.String,
+		directory: Session.AbsolutePath
+	})),
 	/** Its unfinished run was cut off by restarts too often to resume on its own; the next prompt runs it. */
-	parked: optional(Schema.Boolean)
+	parked: optional(Schema.Boolean),
+	usage: ThreadUsage,
+	session: SessionInfo
 });
-/** One message on a session's active branch, oldest first. */
+/** A thread of a session: `threadId`, or the session's `main` thread when absent. */
+const ThreadRef = {
+	sessionId: Session.SessionSchema.ID,
+	threadId: optional(ThreadSchema.ID)
+};
+/** One message in a thread's line (inherited ones first), oldest first. */
 const HistoryEntry = Schema.Struct({
-	/** The entry id: what live events and `session.message` refer to. */
+	/** The entry id: what live events and `thread.message` refer to. */
 	id: Schema.String,
+	/** The thread that wrote it: this one, or a source it was forked from. */
+	threadId: Schema.String,
 	/** Its place in the session's durable log; live events continue from it. */
 	seq: Schema.Int,
 	role: Schema.Literals(["user", "assistant"]),
@@ -194,12 +244,13 @@ const LogSynced = Schema.Struct({
 	aggregateId: Schema.String,
 	seq: optional(Schema.Int)
 });
+/** A thread's model and thinking choices: a given field replaces the stored one, `null` clears it. */
 const RuntimeConfig = Schema.Struct({
-	model: optional(Schema.Struct({
+	model: optional(Schema.NullOr(Schema.Struct({
 		provider: Schema.String,
 		id: Schema.String
-	})),
-	thinkingLevel: optional(Schema.Enum(Model.ThinkingLevelEnum))
+	}))),
+	thinkingLevel: optional(Schema.NullOr(Schema.Enum(Model.ThinkingLevelEnum)))
 });
 const SandboxRef = Sandbox.Selection;
 /** A model to choose, by the catalog's id and display name, with the thinking levels it supports. */
@@ -251,9 +302,11 @@ const OAuthInfo = Schema.Struct({
 });
 const SessionErrors = Schema.Union([
 	SessionStore.SessionNotFoundError,
+	ThreadStore.ThreadNotFoundError,
 	SessionStore.SessionLinkedSpaceNotFoundError,
 	SessionStore.RelinkError
 ]);
+const ThreadErrors = Schema.Union([SessionStore.SessionNotFoundError, ThreadStore.ThreadNotFoundError]);
 const SandboxErrors = Schema.Union([
 	SandboxError.SandboxNotFoundError,
 	SandboxError.SandboxDriverNotRegisteredError,
@@ -302,8 +355,10 @@ const Api = RpcGroup.make(
 		success: Schema.Void,
 		error: OAuthError$1
 	}),
+	/** A session and its `main` thread; the main thread's info, with the session embedded. */
 	Rpc.make("session.create", {
 		payload: {
+			/** The main thread's title; absent = its first prompt names it. */
 			title: optional(Schema.String),
 			directory: optional(Schema.String),
 			/**
@@ -325,7 +380,7 @@ const Api = RpcGroup.make(
 			*/
 			project: optional(Schema.Struct({ name: ProjectName }))
 		},
-		success: SessionInfo,
+		success: ThreadInfo,
 		error: Schema.Union([
 			SessionErrors,
 			SandboxErrors,
@@ -365,39 +420,67 @@ const Api = RpcGroup.make(
 		}),
 		error: Schema.Union([Settings.SettingsError, Runner.ModelCatalogError])
 	}),
-	Rpc.make("session.list", {
-		payload: {},
-		success: Schema.Array(SessionInfo)
-	}),
 	/**
-	* The conversation on a session's active branch: user and assistant messages, oldest first.
-	* Other branches and the harness's own entries (compactions, summaries) are left out.
+	* Point an existing session at a host directory, or clear it with `null`.
+	*
+	* Not `session.relink`: that moves where the *work* happens, this changes which host directory
+	* the session is *anchored to*. Conflating them would recreate exactly the `cwd`/`hostDir`
+	* confusion the split exists to remove, which is why they sound alike and stay apart.
 	*/
-	Rpc.make("session.history", {
-		payload: { sessionId: Session.SessionSchema.ID },
-		success: Schema.Struct({ entries: Schema.Array(HistoryEntry) }),
+	Rpc.make("session.link", {
+		payload: {
+			sessionId: Session.SessionSchema.ID,
+			/** Absent clears the anchor, leaving the session with no host directory. */
+			hostDir: optional(Session.AbsolutePath)
+		},
+		success: SessionInfo,
 		error: SessionStore.SessionNotFoundError
 	}),
 	/**
-	* Prompts admitted but not yet promoted, in admission order. Admission and promotion are
-	* durable events, so a client following `session.log` rereads this whenever the log moves.
+	* Moves where the work happens. Without `threadId`, the session's default space and directory,
+	* which every thread without its own placement follows; with it, that thread's placement only.
+	* Answers with the addressed thread (`main` when absent): its `placement` and embedded session
+	* show where it now runs.
 	*/
-	Rpc.make("session.queue", {
+	Rpc.make("session.relink", {
+		payload: {
+			sessionId: Session.SessionSchema.ID,
+			threadId: optional(ThreadSchema.ID),
+			sandbox: optional(SandboxRef),
+			directory: optional(Schema.String)
+		},
+		success: ThreadInfo,
+		error: Schema.Union([
+			SessionErrors,
+			SandboxErrors,
+			LocationErrors
+		])
+	}),
+	/** Stops every thread, then removes the session with its log. `deleted` is false when it did not exist. */
+	Rpc.make("session.delete", {
 		payload: { sessionId: Session.SessionSchema.ID },
-		success: Schema.Struct({ entries: Schema.Array(QueuedPrompt) }),
-		error: SessionStore.SessionNotFoundError
+		success: Schema.Struct({ deleted: Schema.Boolean })
+	}),
+	/** Interrupts every running thread of the session. */
+	Rpc.make("session.interrupt", {
+		payload: { sessionId: Session.SessionSchema.ID },
+		success: Schema.Struct({ interrupted: Schema.Boolean })
 	}),
 	/**
 	* A session's durable events after `after` (exclusive; omitted reads from the start), then a
 	* `log.synced` marker at the head read when the call began. With `follow`, each event then
-	* streams as it commits; without it the stream ends at the marker.
+	* streams as it commits; without it the stream ends at the marker. Every thread of the session
+	* writes this one log; events name their `threadId`.
 	* Ephemeral events (text and tool progress deltas) are never stored, so they are not here;
 	* `event.subscribe` carries them live. To resume, pass the higher of the last event's
 	* `durable.seq` and the last marker's `seq`: the marker can sit past the last event sent.
+	* With `threadId`, only that thread's events; the marker still names the session's head. A fork's
+	* own log starts at its `session.thread.forked`: what it inherits is in `thread.history`.
 	*/
 	Rpc.make("session.log", {
 		payload: {
 			sessionId: Session.SessionSchema.ID,
+			threadId: optional(ThreadSchema.ID),
 			after: optional(Schema.Int),
 			follow: optional(Schema.Boolean)
 		},
@@ -405,105 +488,118 @@ const Api = RpcGroup.make(
 		error: Schema.Union([SessionStore.SessionNotFoundError, EncodingError]),
 		stream: true
 	}),
-	Rpc.make("session.configure", {
-		payload: {
-			sessionId: Session.SessionSchema.ID,
-			runtime: RuntimeConfig
-		},
-		success: SessionInfo,
-		error: SessionStore.SessionNotFoundError
+	/** Threads newest first, each with its session embedded: of one session, or all. */
+	Rpc.make("thread.list", {
+		payload: { sessionId: optional(Session.SessionSchema.ID) },
+		success: Schema.Array(ThreadInfo)
 	}),
-	Rpc.make("session.info", {
-		payload: { sessionId: Session.SessionSchema.ID },
-		success: SessionInfo,
-		error: SessionStore.SessionNotFoundError
+	Rpc.make("thread.info", {
+		payload: ThreadRef,
+		success: ThreadInfo,
+		error: ThreadErrors
 	}),
 	/**
-	* Point an existing session at a host directory, or clear it with `null`.
-	*
-	* Not `session.relink`: that moves where the *work* happens, this changes which host directory
-	* the session is *anchored to*. Conflating them would recreate exactly the `cwd`/`hostDir`
-	* confusion the split exists to remove, which is why they sound alike and stay apart.
+	* The conversation in a thread's line: user and assistant messages, inherited ones first, oldest
+	* first. The harness's own entries (compactions, resets, notices) are left out.
 	*/
-	Rpc.make("session.link", {
+	Rpc.make("thread.history", {
+		payload: ThreadRef,
+		success: Schema.Struct({ entries: Schema.Array(HistoryEntry) }),
+		error: ThreadErrors
+	}),
+	/**
+	* Prompts admitted to the thread but not yet promoted, in admission order. Admission and
+	* promotion are durable events, so a client following `session.log` rereads this whenever the
+	* log moves.
+	*/
+	Rpc.make("thread.queue", {
+		payload: ThreadRef,
+		success: Schema.Struct({ entries: Schema.Array(QueuedPrompt) }),
+		error: ThreadErrors
+	}),
+	Rpc.make("thread.configure", {
 		payload: {
-			sessionId: Session.SessionSchema.ID,
-			/** Absent clears the anchor, leaving the session with no host directory. */
-			hostDir: optional(Session.AbsolutePath)
+			...ThreadRef,
+			runtime: RuntimeConfig
 		},
-		success: SessionInfo,
-		error: SessionStore.SessionNotFoundError
+		success: ThreadInfo,
+		error: ThreadErrors
 	}),
-	Rpc.make("session.relink", {
+	/**
+	* A new thread whose history continues from this one's line through `entryId`, which must be
+	* committed. `before` stops at the entry's predecessor and returns its text to edit again.
+	*/
+	Rpc.make("thread.fork", {
 		payload: {
-			sessionId: Session.SessionSchema.ID,
-			sandbox: optional(SandboxRef),
-			directory: optional(Schema.String)
+			...ThreadRef,
+			entryId: Schema.String,
+			mode: optional(Schema.Literals(["at", "before"]))
 		},
-		success: SessionInfo,
-		error: Schema.Union([
-			SessionErrors,
-			SandboxErrors,
-			LocationErrors
-		])
+		success: Schema.Struct({
+			thread: ThreadInfo,
+			text: optional(Schema.String)
+		}),
+		error: Schema.Union([ThreadErrors, ThreadStore.ForkError])
 	}),
-	Rpc.make("session.prompt", {
+	Rpc.make("thread.prompt", {
 		payload: {
-			sessionId: Session.SessionSchema.ID,
+			...ThreadRef,
 			text: Schema.String,
 			delivery: optional(PromptSchema.Delivery),
 			id: optional(Session.SessionMessageSchema.ID)
 		},
-		success: Schema.Void,
-		error: Schema.Union([SessionStore.SessionNotFoundError, Control.PromptConflictError])
+		success: Schema.Struct({ threadId: ThreadSchema.ID }),
+		error: Schema.Union([ThreadErrors, Control.PromptConflictError])
 	}),
 	/**
 	* Withdraws a queued prompt before it joins the conversation. `cancelled` is false when it had
 	* already been promoted (it then stays in the conversation) or no pending prompt has that id.
 	*/
-	Rpc.make("session.cancel", {
+	Rpc.make("thread.cancel", {
 		payload: {
-			sessionId: Session.SessionSchema.ID,
+			...ThreadRef,
 			messageId: Session.SessionMessageSchema.ID
 		},
 		success: Schema.Struct({ cancelled: Schema.Boolean }),
-		error: SessionStore.SessionNotFoundError
+		error: ThreadErrors
 	}),
 	/**
 	* Moves a queued prompt to the other lane or rewrites it, keeping its place in the queue.
-	* `delivery: "steer"` also wakes the session, so a prompt left waiting after a stop runs now.
+	* `delivery: "steer"` also wakes the thread, so a prompt left waiting after a stop runs now.
 	* `updated` is false when it had already been promoted or cancelled, or no pending prompt has that id.
 	*/
-	Rpc.make("session.update", {
+	Rpc.make("thread.update", {
 		payload: {
-			sessionId: Session.SessionSchema.ID,
+			...ThreadRef,
 			messageId: Session.SessionMessageSchema.ID,
 			delivery: optional(PromptSchema.Delivery),
 			text: optional(Schema.String)
 		},
 		success: Schema.Struct({ updated: Schema.Boolean }),
-		error: SessionStore.SessionNotFoundError
+		error: ThreadErrors
 	}),
-	Rpc.make("session.interrupt", {
-		payload: { sessionId: Session.SessionSchema.ID },
-		success: Schema.Struct({ interrupted: Schema.Boolean })
+	Rpc.make("thread.interrupt", {
+		payload: ThreadRef,
+		success: Schema.Struct({ interrupted: Schema.Boolean }),
+		error: ThreadErrors
 	}),
 	/**
-	* Whether a prompt materialized into the conversation. An admitted prompt
-	* that is still queued has no entry yet, so this is the projection a client
-	* reconciles against when the volatile stream left it unsure
+	* Whether a prompt materialized into the thread's conversation. An admitted prompt that is still
+	* queued has no entry yet, so this is the projection a client reconciles against when the
+	* volatile stream left it unsure.
 	*/
-	Rpc.make("session.message", {
+	Rpc.make("thread.message", {
 		payload: {
-			sessionId: Session.SessionSchema.ID,
+			...ThreadRef,
 			messageId: Session.SessionMessageSchema.ID
 		},
-		success: Schema.Struct({ found: Schema.Boolean })
+		success: Schema.Struct({ found: Schema.Boolean }),
+		error: ThreadErrors
 	}),
-	Rpc.make("session.wait", {
-		payload: { sessionId: Session.SessionSchema.ID },
+	Rpc.make("thread.wait", {
+		payload: ThreadRef,
 		success: Schema.Void,
-		error: SessionStore.SessionNotFoundError
+		error: ThreadErrors
 	}),
 	/**
 	* Re-import every configured plugin, for the whole server.
@@ -548,8 +644,12 @@ const Api = RpcGroup.make(
 		success: Schema.Void,
 		error: SandboxErrors
 	}),
+	/**
+	* Every event the server publishes, live, after a `server.connected` frame. With `threadId`,
+	* only the events naming that thread; the frame still comes first.
+	*/
 	Rpc.make("event.subscribe", {
-		payload: {},
+		payload: { threadId: optional(ThreadSchema.ID) },
 		success: EventEnvelope,
 		error: Schema.Union([Event.SubscriptionOverflowError, EncodingError]),
 		stream: true
@@ -568,7 +668,7 @@ var ExecutionError = class extends Schema.TaggedError()("Client.ExecutionError",
 /**
 * Runs one prompt against a server and renders its output.
 *
-* Sessions are shared, so the stream carries other clients' work too and every
+* Threads are shared, so the stream carries other clients' work too and every
 * terminal event has to be attributed before it is believed. A terminal that
 * arrives before our own prompt is promoted belongs to somebody else's drain:
 * it is remembered rather than raised, and forgotten the moment our prompt is
@@ -594,9 +694,9 @@ const run = Effect.fn("Client.run")(function* (rpc, input, render) {
 			...event.data.error.status === void 0 ? {} : { status: event.data.error.status }
 		});
 	};
-	const consume = rpc["event.subscribe"]({}).pipe(Stream.mapEffect(Effect.fnUntraced(function* (envelope) {
+	const consume = rpc["event.subscribe"]({ threadId: input.threadId }).pipe(Stream.mapEffect(Effect.fnUntraced(function* (envelope) {
 		if (envelope.type === Connected.type) {
-			yield* rpc["session.prompt"]({
+			yield* rpc["thread.prompt"]({
 				...input,
 				id,
 				delivery: "followUp"
@@ -604,7 +704,7 @@ const run = Effect.fn("Client.run")(function* (rpc, input, render) {
 			return;
 		}
 		const event = yield* decode$1(envelope).pipe(Effect.catchTag("UnknownEventTypeError", () => Effect.void));
-		if (event === void 0 || !Predicate.hasProperty(event.data, "sessionId") || event.data.sessionId !== input.sessionId) return;
+		if (event === void 0) return;
 		if (Schema.is(EventList.PromptAdmitted)(event) && event.data.messageId === id) admitted = true;
 		if (Schema.is(EventList.Prompted)(event) && event.data.messageId === id) {
 			promoted = true;
@@ -626,8 +726,12 @@ const run = Effect.fn("Client.run")(function* (rpc, input, render) {
 		yield* render(event);
 	})), Stream.takeUntil(() => settled), Stream.runDrain);
 	let abandoned = false;
-	const reconcile = Deferred.await(stalled).pipe(Effect.andThen(rpc["session.wait"]({ sessionId: input.sessionId })), Effect.andThen(rpc["session.message"]({
+	const reconcile = Deferred.await(stalled).pipe(Effect.andThen(rpc["thread.wait"]({
+		sessionId: input.sessionId,
+		threadId: input.threadId
+	})), Effect.andThen(rpc["thread.message"]({
 		sessionId: input.sessionId,
+		threadId: input.threadId,
 		messageId: id
 	})), Effect.andThen(({ found }) => found ? Effect.never : Effect.sync(() => {
 		abandoned = true;
@@ -683,6 +787,8 @@ const usage = (summary, columns) => {
 	return `${divider("usage", columns)}${row("model", model)}${row("tokens", `${number.format(summary.input)} input · ${number.format(summary.output)} output${reasoning} · ${number.format(summary.totalTokens)} total`)}${row("cache", `${number.format(summary.cacheRead)} read · ${number.format(summary.cacheWrite)} write`)}${row("cost", `${formatCost(summary.cost)} · ${turns}`)}`;
 };
 const writeOut = (value) => Effect.sync(() => void process.stdout.write(value));
+/** A value in its wire form, as indented JSON. */
+const writeJson = (schema, value) => Schema.encodeEffect(schema)(value).pipe(Effect.orDie, Effect.flatMap((encoded) => writeOut(`${JSON.stringify(encoded, null, "	")}\n`)));
 const writeError = (value) => Effect.sync(() => void process.stderr.write(value));
 const terminalColumns = () => process.stderr.isTTY ? process.stderr.columns ?? 72 : 72;
 //#endregion
@@ -844,6 +950,6 @@ const reportFailure = (error) => writeError(renderError(error)).pipe(Effect.andT
 	process.exitCode = 1;
 })));
 //#endregion
-export { path as _, addUsage as a, Core as b, terminalColumns as c, writeOut as d, layer as f, OAuthError$1 as g, Api as h, reportFailure as i, usage as l, run as m, OAuthError as n, emptyUsage as o, make as p, renderError as r, header as s, InvalidInputError as t, writeError as u, decode as v, encode as x, Connected as y };
+export { encode as C, Core as S, OAuthError$1 as _, addUsage as a, decode as b, terminalColumns as c, writeJson as d, writeOut as f, Api as g, run as h, reportFailure as i, usage as l, make as m, OAuthError as n, emptyUsage as o, layer as p, renderError as r, header as s, InvalidInputError as t, writeError as u, ThreadInfo as v, ofThread as w, Connected as x, path as y };
 
-//# sourceMappingURL=error-BMI81XvR.mjs.map
+//# sourceMappingURL=error-CSeYCa9R.mjs.map