@teamscala/service-boot 0.23.323 → 0.23.324

package/src/fn-routers/task-sync-assign.d.ts

@@ -1,305 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- * @indivisible-unit
- * @edit edit directly
- *
- * Lane DISPATCH by assignment — the WRITE half of dispatch-by-assignment. The
- * operator's contract (verbatim intent): you create a task (the NAME), you write
- * the first COMMENT (which IS the prompt/brief), and THEN you assign it to an AI
- * agent — and the assignment is the TRIGGER that spawns the lane. Assignment
- * last, always, because by the time the agent exists every piece of information
- * it needs is already in the row.
- *
- * This file owns the two pure halves of that flow, split out of task-sync-router
- * (which sits at its 1000-line commit gate, so any new task-sync unit lands in a
- * sibling — the same reason task-sync-brief/lane/dispatch exist):
- *   createTaskWithBriefComment — create the task AND its first comment (the
- *     description IS the first comment IS the brief) in one transaction. An
- *     incomplete task is UNCONSTRUCTIBLE: the ORPC `.input()` schema
- *     (`assignTaskInput`) requires name + description TOGETHER, so oRPC rejects
- *     the call before the handler runs (`prevention-over-detection` — require at
- *     the signature, never validate after the fact).
- *   buildAssignmentSpawnPayload — shape the spawn emission that the assignment
- *     emits. It carries the task id and NO initialPrompt, because the spawned
- *     lane PULLS its brief from the DB by its own session id
- *     (`task-sync-brief.ts` readAssignedBrief → latest comment). That deletes the
- *     keystroke-brief failure class (a ~4400-char initialPrompt fails outright;
- *     a ~2600-char one arrives intact and is never submitted, then the pane is
- *     reaped for producing no turn): when the brief is a row, no keystroke can
- *     lose it.
- *
- * THE EMISSION is a row write followed by an emission that triggers the spawn
- * (`actions-are-rows-then-emissions`): the assignment writes the task + comment,
- * then emits; the host-command bus consumer reacts by spawning. State lives in
- * the row, never in a return value a caller may never receive. The exact bus
- * surface this file emits through is INJECTED (AssignmentEmitter) rather than
- * hard-coded, so it composes with whichever surface the host-command-bus cutover
- * lands — one mechanism, not two (`no-silent-reverts` on the spawn path).
- *
- * BINDING (the gap this flow exposes). A lane resolves its task by its CLI-native
- * session id (`kind_data.lane.session`, minted by the CLI at boot — never by us).
- * Today `ensureLaneTask`/`bindLane` CREATE a fresh parent task at SessionStart.
- * But assignment PRE-CREATES the task (with the brief as its first comment, no
- * session yet), so SessionStart must ADOPT THAT EXISTING TASK BY ID — writing the
- * freshly-minted session onto its `kind_data.lane.session` — instead of creating
- * a new one, or the brief-task is orphaned and the lane self-briefs to nothing.
- * The task is created `status:"active"` with no session, so `resolveLaneTask`
- * (which filters `kind_data.lane.session`) cannot see it until bind writes the
- * session — exactly right: the lane resolves it only after it is bound.
- *
- * CAPABILITY HARVEST (capability-harvest-on-split): APP-LOCAL, not a capability
- * candidate. Bound to the work_items + comments schema and to task-sync's own
- * kind_data.lane.session convention; no unrelated app could install this
- * unmodified.
- */
-import * as v from "valibot";
-import type { Prisma, WorkItem } from "./task-sync-router.ts";
-import { type Context } from "./auth-router.ts";
-export declare const assignTaskInput: v.ObjectSchema<{
-    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, "name is required — the lane's real work label">, v.CheckAction<string, "name must carry the lane's real work name, not the generic sentinel 'Lane'">]>;
-    readonly description: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, "description is required — it is the brief (first comment)">]>;
-    readonly parent_id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-    readonly organisation_id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-    readonly slug: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-    readonly windowName: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-    readonly idempotencyKey: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-}, undefined>;
-/** The resolved (post-schema) shape the handlers operate on. */
-export type AssignTaskInput = v.InferOutput<typeof assignTaskInput>;
-/**
- * bindLane ORPC input. Declaring the schema is the documented remedy for the
- * schema-less-body gap (`upsertFromTaskListInput` cites the same measured bug):
- * oRPC does NOT parse a JSON body into `input` for a procedure with no
- * `.input()`, so a SessionStart adapter that POSTs the work item id as a DIRECT
- * body field (`{lane:{...}, parent_id}`) arrives as an EMPTY input — `parent_id`
- * is silently dropped, `adoptAssignmentTask` gets null, no adoption happens, and
- * `readAssignedBrief` returns nulls for a session that has nothing bound to it.
- * That is a DATA gap (nothing bound to the session), never a serving one — which
- * is exactly the misdiagnosis this closes: a prior lane read those nulls as
- * "fn.taskSync is 404" and reached for serving changes, when the row was simply
- * never bound because the body never parsed.
- *
- * ROOT-OPTIONAL (`v.optional(v.object(...))`) so it tolerates a caller that sends
- * a DIRECT body or none at all: oRPC extracts `input` from the `{json:{...}}` RPC
- * envelope, so a raw-object or empty POST yields `undefined`, which the optional
- * root ACCEPTS — the handler then falls back to its headers, exactly as it did
- * schema-less (a header-only caller like zerostack is unchanged). An adapter that
- * wants the body path (pi's `parent_id`) POSTs the `{json:{...}}` envelope and
- * `parent_id` is parsed + reaches `adoptAssignmentTask` — the same envelope
- * convention pi ALREADY uses for upsertFromTaskList. A raw-object POST is NOT
- * parsed (oRPC hands the handler `undefined`), which is why pi's bindLaneTask
- * must move to the envelope to deliver `parent_id`. Every field is optional with
- * a header fallback, so the schema ADDS the body path without removing the header.
- */
-export declare const bindLaneInput: v.OptionalSchema<v.ObjectSchema<{
-    readonly lane: v.OptionalSchema<v.ObjectSchema<{
-        readonly pane: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        readonly session: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        readonly cli_kind: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        readonly role: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        readonly organisation_id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-    }, undefined>, undefined>;
-    readonly title: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-    readonly parent_id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-}, undefined>, undefined>;
-/**
- * Resolve the org a dispatched task is created under. Pure: the platform org is
- * INJECTED (resolved by the caller at the handler boundary, where a registry
- * read is appropriate) rather than pulled from the registry inside this module,
- * so the create logic is unit-testable with no DB (`configured-primitives`:
- * config arrives from the caller, never pulled from DB/Env inside a primitive).
- */
-export declare function resolveAssignOrg(explicit?: string, platformOrg?: string): string;
-/**
- * Create a dispatched task AND its first comment (the description = the brief) in
- * one transaction. The task is `kind:"task"`, `status:"active"`, with NO
- * `kind_data.lane.session` yet — the session is minted by the CLI at spawn and
- * written onto the row by SessionStart's adopt-existing bind. Until then the
- * task is invisible to `resolveLaneTask` (which filters on the session), which is
- * correct: the lane may only resolve its task once it is bound to it.
- *
- * Pure over an injected prisma (no module-level I/O) so the atomic create +
- * first-comment decision is unit-testable with a fake transaction. `userId`
- * stamps `created_by`/`updated_by` on the task and `user_id` on the comment.
- */
-export declare function createTaskWithBriefComment(prisma: Prisma, input: {
-    name: string;
-    description: string;
-    parent_id?: string;
-    organisation_id: string;
-}, userId: string): Promise<WorkItem>;
-/**
- * ADOPT a pre-created assignment task at SessionStart: write the lane's
- * freshly-minted session onto an EXISTING task row instead of creating a new
- * one. `bindLane` calls this when the spawn carried a `workItemId` that resolves
- * to a `kind:"task"` row (the assignment task whose first comment IS the brief).
- * Without this, bindLane would CREATE a new task and orphan the brief-task — the
- * lane would `readAssignedBrief` to nothing.
- *
- * Realizes OWNERSHIP too: sets `assignee_id` to the lane's session (its stable
- * identity, `lane-identity-is-cli-session-id`), so the compliance gate can
- * distinguish a task the CALLER owes from one a dispatched lane owns (the
- * orchestrator supervises, not implements — `anthropic-models-orchestrate-not-
- * implement`). "Is the caller the assignee" becomes a simple equality on the
- * session.
- *
- * RE-BINDS a task another session already owns. Migration 109
- * (`work_items_one_active_task_per_lane`) makes `(kind_data->'lane'->>'pane')`
- * unique WHERE active, so when a lane is re-spawned on a pane whose prior task is
- * still active under a STALE session (the lane died, the row survived),
- * `resolveLaneTask(newSession)` finds nothing and `create` P2002s — measured
- * fleet-wide 2026-08-01: every real lane's bindLane 500'd on this constraint.
- * Refusing to steal (the original design) routes every re-spawn into that
- * dead-end. An assignment task belongs to whichever lane was dispatched to it,
- * and a stale session is by definition dead, so re-binding to the fresh session
- * is the correct recovery: the pane's unique slot moves to the live lane and
- * the brief follows. Returns null only when `maybeTaskId` is absent or not a
- * task — caller falls through to create for an exploratory lane (no workItemId).
- */
-export declare function adoptAssignmentTask(prisma: Prisma, maybeTaskId: string | null | undefined, lane: {
-    session: string;
-    pane: string | null;
-    cli_kind?: string;
-    role?: string;
-}): Promise<WorkItem | null>;
-/**
- * The bind decision AFTER attempting to adopt the spawn's referenced task. PURE
- * over the adopt result + whether the referenced row exists, so the
- * "a spawn that cannot bind fails loudly rather than orphaning" invariant
- * (`absent-input-reads-as-success`) is unit-testable without standing up the
- * ORPC handler. `bindLane` calls `adoptAssignmentTask` then this, then acts.
- *
- *   `use`     — adopt succeeded; bind the lane to that task.
- *   `create`  — no task to adopt: an exploratory lane (no workItemId) or the
- *               referenced id is a PROJECT the task is created under.
- *   `refuse`  — the spawn named a workItemId the lane should adopt, but NO task
- *               exists with that id. Silently creating a NEW task here would
- *               abandon the spawn's referenced brief and bind the lane to an
- *               empty task it was never meant to own — exactly the orphan
- *               `absent-input-reads-as-success` forbids (a caller that stated
- *               adopt-intent reads "success" while the referenced row rots).
- *               Failing loudly surfaces the malformed spawn instead.
- */
-export type BindAction = {
-    action: "use";
-    task: WorkItem;
-} | {
-    action: "create";
-    scope: "exploratory" | "project-parent";
-} | {
-    action: "refuse";
-    reason: "missing-referenced-task";
-    workItemId: string;
-};
-export declare function resolveBindAction(args: {
-    adopted: WorkItem | null;
-    workItemId: string | null;
-    /** The kind of the row at workItemId, or null when no such row exists. */
-    referencedKind: string | null;
-}): BindAction;
-/**
- * Bind a task to a KNOWN session — the RESUME path. Unlike a fresh spawn (the
- * CLI mints the session at boot, so SessionStart must adopt), a resumed/switched
- * lane knows its session id up front (`resumeId`). So the assignment binds the
- * task to `resumeId` directly and writes a NEW comment as the continuation brief,
- * before emitting the spawn with `resumeId`. `readAssignedBrief(resumeId)` then
- * returns that continuation — so `DEFAULT_CONTINUATION_PROMPT`'s job (which rode
- * the now-retired keystroke path) moves to a row write at assign time. Also sets
- * `assignee_id` (ownership) for the same reason as the fresh-spawn adopt.
- */
-export declare function bindTaskToKnownSession(prisma: Prisma, taskId: string, lane: {
-    session: string;
-    pane: string | null;
-    cli_kind?: string;
-    role?: string;
-}): Promise<WorkItem | null>;
-/**
- * The spawn payload an assignment emits. Carries the task id (as `workItemId`,
- * which the picker exports into the pane so SessionStart can ADOPT the existing
- * task) and NEVER an `initialPrompt` — the lane pulls its brief from the DB by
- * its own session id. This is the contract whatever host-command surface lands:
- * command `spawn_agent_tab`, payload `{ workItemId, slug?, windowName?,
- * idempotencyKey? }`.
- *
- * Pure (no I/O) so the "no keystroke brief, taskId-only" invariant is
- * unit-testable and regression-locked: a test asserting `initialPrompt` is
- * absent fails the moment someone re-adds keystroke delivery.
- */
-export declare function buildAssignmentSpawnPayload(task: Pick<WorkItem, "id">, options: {
-    slug?: string;
-    windowName?: string;
-    idempotencyKey?: string;
-}): {
-    command: "spawn_agent_tab";
-    payload: {
-        workItemId: string;
-        slug?: string;
-        windowName?: string;
-        idempotencyKey?: string;
-    };
-};
-/**
- * The emission surface an assignment writes the spawn intent to. Injected (not
- * imported) so this file composes with whichever bus surface the host-command-bus
- * cutover settles on, rather than hard-coding a second mechanism. Implementations
- * write a durable row the consumer reacts to (`actions-are-rows-then-emissions`):
- * fire-and-forget from the caller's perspective — the caller states intent and
- * proceeds; the consumer spawns the lane and the lane self-briefs.
- */
-export interface AssignmentEmitter {
-    /** Write the spawn intent as a durable row the host-command consumer reacts to. */
-    emitSpawn(payload: ReturnType<typeof buildAssignmentSpawnPayload>): Promise<void>;
-}
-/**
- * The outcome of assigning a task: the created/confirmed task and confirmation
- * that the spawn intent was emitted (not that the lane spawned — that is the
- * consumer's reaction, observed separately). The caller proceeds on the row.
- */
-export interface AssignmentResult {
-    task: WorkItem;
-    emitted: boolean;
-}
-/**
- * createBriefTask ORPC input. The MINT entry point a spawner calls to turn a
- * raw brief into the task row a lane self-briefs from. `name` is the lane's work
- * label (the spawner's windowName); `description` is the brief, stored as the
- * task's FIRST COMMENT — never on the task row itself, so "the brief" has
- * exactly one home (`task-sync-brief.ts` readLatestTaskComment, newest-first).
- * Mirrors `assignTaskInput` minus the spawn-shaping fields (slug/windowName/
- * idempotencyKey), which belong on the spawn emission, not the mint.
- */
-export declare const createBriefTaskInput: v.ObjectSchema<{
-    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, "name is required — the lane's real work label">, v.CheckAction<string, "name must carry the lane's real work name, not the generic sentinel 'Lane'">]>;
-    readonly description: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, "description is required — it is the brief (first comment)">]>;
-    readonly parent_id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-    readonly organisation_id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-}, undefined>;
-/**
- * createBriefTask ORPC handler. `spawn_agent_tab` calls this when it receives
- * an `initialPrompt` with no `workItemId`: the prompt becomes the task's first
- * comment, the returned `work_item_id` rides the spawn payload as `workItemId`,
- * and the lane PULLS the brief at boot (`readAssignedBrief`) — no keystroke, no
- * channel send, no positional argument. That deletes the keystroke-brief
- * failure class by construction (`buildAssignmentSpawnPayload` already carries
- * `workItemId` and never `initialPrompt`).
- *
- * Wraps the pure `createTaskWithBriefComment` (atomic task + first comment). The
- * task is `kind:"task"`, `status:"active"`, `assignee_type:"agent"`, with NO
- * `kind_data.lane.session`: the CLI mints the session at spawn and SessionStart
- * ADOPTS this task by id (`adoptAssignmentTask`), which binds the brief to the
- * lane. Returns only the `work_item_id` — the single fact the spawner needs to
- * carry the brief without writing it into the spawn payload. Same transport as
- * `readAssignedBrief`: page-gate-exempt (fn.taskSync), localhost super-admin.
- */
-export declare const createBriefTaskHandler: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<Context & Record<never, never>, Context, Context>, import("@orpc/server").MergedCurrentContext<Context, {
-    headers: Headers;
-    resolveUser?: (headers: Headers, prisma: any) => Promise<import("./auth-router.ts").User | null>;
-    prisma: any;
-    user: import("./auth-router.ts").User;
-    orgId: string | null | undefined;
-}>, import("@orpc/contract").Schema<unknown, unknown>, import("@orpc/contract").Schema<{
-    work_item_id: string;
-}, {
-    work_item_id: string;
-}>, Record<never, never>, Record<never, never>>;

package/src/fn-routers/task-sync-brief.d.ts

@@ -1,96 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- * @edit edit directly
- *
- * Lane BRIEF resolution for task-sync: a spawned lane PULLS its own brief. The
- * lane's CLI extension reads its own session id on load, resolves the task
- * assigned to that session, and reads the brief from that task's LATEST comment.
- * Nothing is pasted, typed, passed as an argument or sent over a channel
- * (`scala-docs/reference/action-emission-architecture.md` "The lane PULLS its
- * brief"). This file owns the readAssignedBrief ORPC handler + its pure helper;
- * the router mounts the handler.
- *
- * Split out of task-sync-router.ts for the same reason task-sync-lane.ts +
- * task-sync-projection.ts exist: the router sits at its 1000-line commit gate,
- * so every cohesive unit that can live in a sibling does. The self-brief leg is
- * one unit — the handler + the response-shaping decision belong together.
- *
- * CAPABILITY HARVEST (capability-harvest-on-split): APP-LOCAL, not a capability
- * candidate. Bound to the work_items + comments schema and to task-sync's own
- * kind_data.lane.session convention; no unrelated app could install this
- * unmodified.
- */
-import type { Prisma, CommentRow } from "./task-sync-router.ts";
-import { type Context } from "./auth-router.ts";
-/**
- * The outcome of a brief read, single-sourced here so every CLI's self-brief
- * hook (zerostack/codex shell, opencode/pi TS) branches on ONE field rather
- * than each re-deriving "is the brief missing" from null/empty probes — the
- * seam at which absent-input-reads-as-success hid (`the-severe-bugs-live-at-seams`).
- *
- * The hook decides ACTION from this; the classification lives here. A fleet
- * lane (SCALA_LANE_WORK_ITEM set) treats anything but "ready" as a hard halt.
- */
-export type BriefReadStatus = "ready" | "empty_brief" | "no_comment" | "unbound";
-/**
- * Shape the readAssignedBrief response from a resolved task + its latest
- * comment. Pure (no prisma) so the decision — "no task/comment ⇒ nulls, never a
- * verdict from no data" (`no-verdict-from-no-data`) — is unit-testable.
- *
- * `work_item_id` is set iff the TASK resolved (independent of whether a comment
- * exists), and `status` distinguishes the four states a hook must act on:
- *   - "ready"        — task + a non-empty comment: inject the brief.
- *   - "empty_brief"  — task resolved, comment exists but content is blank: the
- *                      spawn minted a task with no usable brief — broken.
- *   - "no_comment"   — task resolved, no comment at all: same broken class.
- *   - "unbound"      — no task resolved: the lane has no brief task (a non-fleet
- *                      operator tab, or — for the session-only path — a bind
- *                      that has not yet commit; the work_item_id path cannot
- *                      reach this for a fleet lane).
- *
- * "empty_brief" / "no_comment" with the task resolved is the state the
- * absent-input fix exists to catch: a fleet lane whose spawn succeeded MUST
- * have a non-empty brief comment, so its absence is a defect the hook halts on
- * rather than reading as success.
- */
-export declare function shapeBriefResponse(task: {
-    id: string;
-} | null, comment: Pick<CommentRow, "content" | "created_at"> | null): {
-    work_item_id: string | null;
-    brief: string | null;
-    comment_created_at: string | null;
-    status: BriefReadStatus;
-};
-/**
- * Read the LATEST comment on a work_items task. The comment IS the brief for a
- * run: every spawn writes a NEW comment, and the description is never the brief,
- * so "what was this lane told" always has exactly one answer
- * (`assignment-as-dispatch`). Newest-first by created_at. Returns null when the
- * task has no comment yet — the extension treats that as "no brief to inject".
- */
-export declare function readLatestTaskComment(prisma: Prisma, workItemId: string): Promise<CommentRow | null>;
-/**
- * readAssignedBrief ORPC handler. A lane's CLI extension calls this with its
- * own session id to pull its brief. Same transport as bindLane/readTaskList: the
- * session id arrives on x-lane-session (and body.lane_session as fallback). The
- * procedure is page-gate-exempt (fn.taskSync), so a localhost pane shell
- * authenticates as super-admin via resolveUser with no session cookie.
- */
-export declare const readAssignedBriefHandler: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<Context & Record<never, never>, Context, Context>, import("@orpc/server").MergedCurrentContext<Context, {
-    headers: Headers;
-    resolveUser?: (headers: Headers, prisma: any) => Promise<import("./auth-router.ts").User | null>;
-    prisma: any;
-    user: import("./auth-router.ts").User;
-    orgId: string | null | undefined;
-}>, import("@orpc/contract").Schema<unknown, unknown>, import("@orpc/contract").Schema<{
-    work_item_id: string | null;
-    brief: string | null;
-    comment_created_at: string | null;
-    status: BriefReadStatus;
-}, {
-    work_item_id: string | null;
-    brief: string | null;
-    comment_created_at: string | null;
-    status: BriefReadStatus;
-}>, Record<never, never>, Record<never, never>>;

package/src/fn-routers/task-sync-dispatch.d.ts

@@ -1,61 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- * @edit edit directly
- *
- * DB→AGENT dispatch for task-sync — notifies a lane's live pane that its
- * work_items task list changed out-of-band (operator toggled a subtask in the
- * projects UI, another lane edited a shared task). The pane's adapter then
- * re-reads (fn.taskSync.readTaskList) and updates its native list.
- *
- * MECHANISM — reuses the existing CLI-agnostic channel delivery, no new
- * transport: a POST to scala-channel's fleet-events publish entry
- * (POST /api/fleet/events — @teamscala/channel/fleet-events-publish) carrying an
- * `orchestrator.message` FleetEvent with slotName "cross-pane". That slot is
- * the watchEvents bypass for events NOT tied to a fleet_agent_runs row
- * (FleetEventOrchestratorMessageSchema comment) — exactly the system-originated
- * case. scala-channel re-emits onto its eventBus and streamFleetEvents delivers
- * to the subscriber filtered by orchestratorSessionId (the target lane pane).
- * Both the Claude Code relay and the OpenCode scala-hooks plugin subscribe to
- * that SSE stream for their own pane identity and inject each event natively —
- * so ONE publish reaches every CLI that has a live projection, no per-CLI
- * dispatch code here.
- *
- * NOT the dispatch entry (POST /api/channel/send): that path requires a real
- * sender pane identity (channel-sender-identity-validated anti-spoof) and so
- * cannot carry a system-originated notification. The publish path is
- * internal-trusted (localhost super-admin) and accepts a synthetic
- * fromOrchestratorId — the correct path for a system→pane message.
- *
- * scala-channel's address is resolved from its service_routing row (local_port)
- * — never hardcoded (service-ports-from-registry). Fire-and-forget: a dispatch
- * failure (scala-channel down, port unresolvable) is logged and swallowed; it
- * must never block the work_items write that triggered it, and the lane's
- * SessionStart/UserPromptSubmit backstop picks up the change on its next turn
- * regardless.
- */
-/**
- * The `orchestrator.message` FleetEvent payload that notifies a lane its task
- * list changed. Pure (no I/O) so it is unit-testable; notifyLaneOfTaskChange
- * posts it. slotName "cross-pane" is REQUIRED — it is the watchEvents bypass for
- * events not tied to a fleet_agent_runs row. orchestratorSessionId is the TARGET
- * lane pane (the SSE subscriber filter). The message is single-line (the
- * <channel> tag renders it inline).
- */
-export interface TaskChangedEvent {
-    type: "orchestrator.message";
-    message: string;
-    fromOrchestratorId: string;
-    runId: string;
-    slotName: "cross-pane";
-    ts: number;
-    orchestratorSessionId: string;
-}
-export declare function buildTaskChangedEvent(lanePane: string, taskId: string, now?: number): TaskChangedEvent;
-/**
- * Publish a "your task list changed" notification to the owning lane's pane.
- * The pane identity is the stable tmux id ("tmux:%42") every CLI relay/plugin
- * receives for. `taskId` is carried in the message so the recipient can re-read
- * just that task. Fire-and-forget.
- */
-export declare function notifyLaneOfTaskChange(lanePane: string, taskId: string): Promise<void>;

package/src/fn-routers/task-sync-dispatch.ts

@@ -1,124 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- * @edit edit directly
- *
- * DB→AGENT dispatch for task-sync — notifies a lane's live pane that its
- * work_items task list changed out-of-band (operator toggled a subtask in the
- * projects UI, another lane edited a shared task). The pane's adapter then
- * re-reads (fn.taskSync.readTaskList) and updates its native list.
- *
- * MECHANISM — reuses the existing CLI-agnostic channel delivery, no new
- * transport: a POST to scala-channel's fleet-events publish entry
- * (POST /api/fleet/events — @teamscala/channel/fleet-events-publish) carrying an
- * `orchestrator.message` FleetEvent with slotName "cross-pane". That slot is
- * the watchEvents bypass for events NOT tied to a fleet_agent_runs row
- * (FleetEventOrchestratorMessageSchema comment) — exactly the system-originated
- * case. scala-channel re-emits onto its eventBus and streamFleetEvents delivers
- * to the subscriber filtered by orchestratorSessionId (the target lane pane).
- * Both the Claude Code relay and the OpenCode scala-hooks plugin subscribe to
- * that SSE stream for their own pane identity and inject each event natively —
- * so ONE publish reaches every CLI that has a live projection, no per-CLI
- * dispatch code here.
- *
- * NOT the dispatch entry (POST /api/channel/send): that path requires a real
- * sender pane identity (channel-sender-identity-validated anti-spoof) and so
- * cannot carry a system-originated notification. The publish path is
- * internal-trusted (localhost super-admin) and accepts a synthetic
- * fromOrchestratorId — the correct path for a system→pane message.
- *
- * scala-channel's address is resolved from its service_routing row (local_port)
- * — never hardcoded (service-ports-from-registry). Fire-and-forget: a dispatch
- * failure (scala-channel down, port unresolvable) is logged and swallowed; it
- * must never block the work_items write that triggered it, and the lane's
- * SessionStart/UserPromptSubmit backstop picks up the change on its next turn
- * regardless.
- */
-
-import { loadRegistryConfig } from "@teamscala/db/registry/load-config";
-import { ServiceRoutingConfigSchema } from "@teamscala/db-validation/registry-schemas/service-routing";
-import { getAppLogger } from "@teamscala/logger/app-loggers";
-
-let cachedChannelBaseUrl: string | null | undefined;
-
-async function resolveChannelBaseUrl(): Promise<string | null> {
-	if (cachedChannelBaseUrl !== undefined) return cachedChannelBaseUrl;
-	try {
-		const row = await loadRegistryConfig("service_routing", "scala-channel", ServiceRoutingConfigSchema);
-		const port = row?.local_port;
-		cachedChannelBaseUrl = port ? `http://127.0.0.1:${port}` : null;
-	} catch {
-		cachedChannelBaseUrl = null;
-	}
-	return cachedChannelBaseUrl;
-}
-
-/** The system sender identity stamped on fromOrchestratorId. */
-const FROM_ORCHESTRATOR_ID = "task-sync";
-
-/**
- * The `orchestrator.message` FleetEvent payload that notifies a lane its task
- * list changed. Pure (no I/O) so it is unit-testable; notifyLaneOfTaskChange
- * posts it. slotName "cross-pane" is REQUIRED — it is the watchEvents bypass for
- * events not tied to a fleet_agent_runs row. orchestratorSessionId is the TARGET
- * lane pane (the SSE subscriber filter). The message is single-line (the
- * <channel> tag renders it inline).
- */
-export interface TaskChangedEvent {
-	type: "orchestrator.message";
-	message: string;
-	fromOrchestratorId: string;
-	runId: string;
-	slotName: "cross-pane";
-	ts: number;
-	orchestratorSessionId: string;
-}
-
-export function buildTaskChangedEvent(lanePane: string, taskId: string, now: number = Date.now()): TaskChangedEvent {
-	return {
-		type: "orchestrator.message",
-		message: `TaskSync: your work_items task list changed externally (task ${taskId}). Re-read via fn.taskSync.readTaskList and update your todo list.`,
-		fromOrchestratorId: FROM_ORCHESTRATOR_ID,
-		runId: `task-sync-${taskId}-${now}`,
-		slotName: "cross-pane",
-		ts: now,
-		orchestratorSessionId: lanePane,
-	};
-}
-
-/**
- * Publish a "your task list changed" notification to the owning lane's pane.
- * The pane identity is the stable tmux id ("tmux:%42") every CLI relay/plugin
- * receives for. `taskId` is carried in the message so the recipient can re-read
- * just that task. Fire-and-forget.
- */
-export async function notifyLaneOfTaskChange(
-	lanePane: string,
-	taskId: string,
-): Promise<void> {
-	const log = getAppLogger();
-	if (!lanePane) return;
-	const base = await resolveChannelBaseUrl();
-	if (!base) {
-		log.warn("[task-sync] notifyLaneOfTaskChange: scala-channel address unresolvable", { taskId });
-		return;
-	}
-	const payload = buildTaskChangedEvent(lanePane, taskId);
-	try {
-		const res = await fetch(`${base}/api/fleet/events`, {
-			method: "POST",
-			headers: { "content-type": "application/json" },
-			body: JSON.stringify(payload),
-			signal: AbortSignal.timeout(3000),
-		});
-		if (!res.ok) {
-			log.warn("[task-sync] notifyLaneOfTaskChange: non-2xx from scala-channel", {
-				taskId, status: res.status,
-			});
-		}
-	} catch (err) {
-		log.warn("[task-sync] notifyLaneOfTaskChange: POST failed", {
-			taskId, error: err instanceof Error ? err.message : String(err),
-		});
-	}
-}

package/src/fn-routers/task-sync-lane.d.ts

@@ -1,49 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- * @edit edit directly
- *
- * Lane RESOLUTION for task-sync: given a session or a pane, which work_items
- * task IS this lane, and what is it called.
- *
- * Split out of task-sync-router.ts, which had reached 998 of its 1000-line
- * budget — two lines from frozen. That is not tidiness: the budget is a commit
- * gate, so at 998 lines ANY change to task-sync was blocked for every lane, and
- * the four-line fix that needed to land could not. The router header records
- * being split once before for exactly this reason; it grew back.
- *
- * The seam matches the one that split the projection. Everything here answers
- * "which lane, called what" from an identity, and none of it touches the ORPC
- * surface or decides what a task list should become — which is why these move
- * together rather than one at a time: resolveLaneTask alone has seven callers.
- *
- * CAPABILITY HARVEST (capability-harvest-on-split): APP-LOCAL, not a capability
- * candidate. Checked against the 14 platform singletons and the package
- * catalogue; the doctrine test fails plainly, because every export is bound to
- * the work_items schema and to task-sync own kind_data.lane convention, so no
- * unrelated app could install this unmodified.
- */
-import type { Prisma, WorkItem } from "./task-sync-router.ts";
-export declare function resolveLaneWorkName(prisma: Prisma, pane: string): Promise<string | null>;
-export declare function resolveLaneTask(prisma: Prisma, session: string): Promise<WorkItem | null>;
-/**
- * Resolve a lane's task by its AUTHORITATIVE work_item id — the id the spawn
- * minted (createBriefTask) and exported into the pane as SCALA_LANE_WORK_ITEM.
- *
- * WHY this exists alongside the session resolution: readAssignedBrief used to
- * resolve ONLY by kind_data.lane.session, which is written by the lane's OWN
- * bindLane hook at boot. That bind is a fire-and-forget POST racing the brief
- * read, so a fleet lane whose bind had not yet commit read "no task" and the
- * self-brief hook silently exited 0 — absent-input-reads-as-success at the
- * dispatch boundary (a lane booted, was told its brief was loaded, had none,
- * ran nothing, and was archived having done nothing — measured 2026-08-02).
- *
- * The work_item id is known to the spawn before the lane even starts
- * (mintBriefTask returns it; the spawn REFUSES if minting fails for a capture
- * CLI), so resolving by it CANNOT race: the row exists because the spawn
- * created it. The session bind stays for task-list writes (upsertFromTaskList)
- * — it is no longer load-bearing for brief delivery. Any status is matched
- * (active OR archived) because the brief is the brief regardless of the run's
- * state — closing a run archives the task, not the brief.
- */
-export declare function resolveTaskById(prisma: Prisma, workItemId: string): Promise<WorkItem | null>;