@teamscala/service-boot 0.23.345 → 0.23.347

package/src/fn-routers/public-gpt-session-router.d.ts

@@ -1,143 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- * @edit edit directly
- *
- * ORPC procedures for public GPT session management.
- * Creates/restores conversations and messages for public-facing GPT pages.
- */
-import * as v from "valibot";
-interface Context {
-    prisma: any;
-    headers: Headers;
-    resolveUser?: (headers: Headers, prisma: any) => Promise<any>;
-}
-export declare const publicGptSessionRouter: {
-    createOrRestore: import("@orpc/server").DecoratedProcedure<Context & Record<never, never>, Context, v.ObjectSchema<{
-        readonly contactName: v.StringSchema<undefined>;
-        readonly email: v.StringSchema<undefined>;
-        readonly phone: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        readonly gptId: v.StringSchema<undefined>;
-        readonly orgId: v.StringSchema<undefined>;
-        readonly sourceUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-    }, undefined>, import("@orpc/contract").Schema<{
-        conversationId: string;
-        contactName: any;
-        contactPhone: any;
-        messages: any;
-        tokenTotals: {
-            inputTokens: number;
-            outputTokens: number;
-        };
-    } | {
-        conversationId: any;
-        contactName: any;
-        contactPhone: any;
-        messages: never[];
-        tokenTotals: {
-            inputTokens: number;
-            outputTokens: number;
-        };
-    }, {
-        conversationId: string;
-        contactName: any;
-        contactPhone: any;
-        messages: any;
-        tokenTotals: {
-            inputTokens: number;
-            outputTokens: number;
-        };
-    } | {
-        conversationId: any;
-        contactName: any;
-        contactPhone: any;
-        messages: never[];
-        tokenTotals: {
-            inputTokens: number;
-            outputTokens: number;
-        };
-    }>, Record<never, never>, Record<never, never>>;
-    load: import("@orpc/server").DecoratedProcedure<Context & Record<never, never>, Context, v.ObjectSchema<{
-        readonly conversationId: v.StringSchema<undefined>;
-    }, undefined>, import("@orpc/contract").Schema<{
-        conversationId: any;
-        contactName: string;
-        contactEmail: string;
-        messages: any;
-        tokenTotals: {
-            inputTokens: number;
-            outputTokens: number;
-        };
-    } | null, {
-        conversationId: any;
-        contactName: string;
-        contactEmail: string;
-        messages: any;
-        tokenTotals: {
-            inputTokens: number;
-            outputTokens: number;
-        };
-    } | null>, Record<never, never>, Record<never, never>>;
-    saveMessages: import("@orpc/server").DecoratedProcedure<Context & Record<never, never>, Context, v.ObjectSchema<{
-        readonly conversationId: v.StringSchema<undefined>;
-        readonly messages: v.ArraySchema<v.ObjectSchema<{
-            readonly id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-            readonly role: v.StringSchema<undefined>;
-            readonly content: v.StringSchema<undefined>;
-            readonly parts: v.OptionalSchema<v.ArraySchema<v.AnySchema, undefined>, undefined>;
-            readonly metadata: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.AnySchema, undefined>, undefined>;
-        }, undefined>, undefined>;
-    }, undefined>, import("@orpc/contract").Schema<void, void>, Record<never, never>, Record<never, never>>;
-    clear: import("@orpc/server").DecoratedProcedure<Context & Record<never, never>, Context, v.ObjectSchema<{
-        readonly conversationId: v.StringSchema<undefined>;
-    }, undefined>, import("@orpc/contract").Schema<{
-        conversationId: any;
-        contactName: string;
-        contactPhone: string | undefined;
-        messages: Array<{
-            role: string;
-            content: string;
-            parts?: unknown[];
-        }>;
-        tokenTotals: {
-            inputTokens: number;
-            outputTokens: number;
-        };
-    }, {
-        conversationId: any;
-        contactName: string;
-        contactPhone: string | undefined;
-        messages: Array<{
-            role: string;
-            content: string;
-            parts?: unknown[];
-        }>;
-        tokenTotals: {
-            inputTokens: number;
-            outputTokens: number;
-        };
-    }>, Record<never, never>, Record<never, never>>;
-    checkIdentity: import("@orpc/server").DecoratedProcedure<Context & Record<never, never>, Context, v.ObjectSchema<{
-        readonly email: v.StringSchema<undefined>;
-    }, undefined>, import("@orpc/contract").Schema<{
-        isPlatformUser: boolean;
-    }, {
-        isPlatformUser: boolean;
-    }>, Record<never, never>, Record<never, never>>;
-    upload: import("@orpc/server").DecoratedProcedure<Context & Record<never, never>, Context, v.ObjectSchema<{
-        readonly conversationId: v.StringSchema<undefined>;
-        readonly fileData: v.StringSchema<undefined>;
-        readonly fileName: v.StringSchema<undefined>;
-        readonly fileType: v.StringSchema<undefined>;
-        readonly fileSize: v.NumberSchema<undefined>;
-    }, undefined>, import("@orpc/contract").Schema<{
-        success: true;
-        url: string;
-        type: string;
-    }, {
-        success: true;
-        url: string;
-        type: string;
-    }>, Record<never, never>, Record<never, never>>;
-};
-export {};

package/src/fn-routers/sign-in-flow-router.d.ts

@@ -1,107 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- * @edit edit directly
- *
- * `fn.signInFlow` — typed ORPC procedures for the sign-in flow's client-facing
- * reads (flow config, session check, portal list). Replaces the former
- * `/api/data/{sign-in-flow-config,check-session,portals}` HANDLER_MAP entries
- * from the deleted register-data-routes.ts (orpc-is-the-only-api: every API surface is a
- * typed ORPC procedure, never a hand-written Hono route). Logic ported
- * verbatim from those handlers — these are anonymous-allowed reads (they
- * return an empty result for an unauthenticated caller, never throw), so they
- * use a public base procedure reading `context.headers` for the session, NOT
- * the `authed` middleware (which throws UNAUTHORIZED).
- *
- * EXPAND phase: this router is ADDITIVE — registered into the `fn` namespace
- * but not yet retargeted by @teamscala/auth's use-sign-in-flow client (which
- * still hits the /api/data/* routes). The HANDLER_MAP entries stay until the
- * client retarget + round-trip verify land (post-incident, when the auth-flow
- * test harness can run), then are removed (CONTRACT).
- */
-import type { Context } from "./auth-router.ts";
-export declare const signInFlowRouter: {
-    getSignInFlowConfig: import("@orpc/server").DecoratedProcedure<Context & Record<never, never>, Context, import("@orpc/contract").Schema<unknown, unknown>, import("@orpc/contract").Schema<{
-        signInPath: string;
-        portalPathPrefix: string;
-        redirectQueryParam: string;
-        sessionCheckEndpoint: string;
-        portalsEndpoint: string;
-        clearStaleCookiesEndpoint: string;
-        portalRedirects: {
-            orgDashboardPathTemplate: string;
-            individualDashboardPathTemplate: string;
-        };
-    }, {
-        signInPath: string;
-        portalPathPrefix: string;
-        redirectQueryParam: string;
-        sessionCheckEndpoint: string;
-        portalsEndpoint: string;
-        clearStaleCookiesEndpoint: string;
-        portalRedirects: {
-            orgDashboardPathTemplate: string;
-            individualDashboardPathTemplate: string;
-        };
-    }>, Record<never, never>, Record<never, never>>;
-    checkSession: import("@orpc/server").DecoratedProcedure<Context & Record<never, never>, Context, import("@orpc/contract").Schema<unknown, unknown>, import("@orpc/contract").Schema<{
-        user?: undefined;
-        redirectUrl?: undefined;
-        portalCount?: undefined;
-    } | {
-        user: {
-            id: string;
-            email: string;
-            name: string | null;
-            role: string | null;
-        };
-        redirectUrl: string;
-        portalCount: number;
-    }, {
-        user?: undefined;
-        redirectUrl?: undefined;
-        portalCount?: undefined;
-    } | {
-        user: {
-            id: string;
-            email: string;
-            name: string | null;
-            role: string | null;
-        };
-        redirectUrl: string;
-        portalCount: number;
-    }>, Record<never, never>, Record<never, never>>;
-    listPortals: import("@orpc/server").DecoratedProcedure<Context & Record<never, never>, Context, import("@orpc/contract").Schema<unknown, unknown>, import("@orpc/contract").Schema<{
-        portals: never[];
-        userOrgId: null;
-        userName: string | null;
-    } | {
-        portals: {
-            id: unknown;
-            name: {};
-            slug: {} | null;
-            status: {} | null;
-            website_type: {} | null;
-            organisation_id: {} | null;
-            portal_type: {} | null;
-        }[];
-        userOrgId: string;
-        userName: string | null;
-    }, {
-        portals: never[];
-        userOrgId: null;
-        userName: string | null;
-    } | {
-        portals: {
-            id: unknown;
-            name: {};
-            slug: {} | null;
-            status: {} | null;
-            website_type: {} | null;
-            organisation_id: {} | null;
-            portal_type: {} | null;
-        }[];
-        userOrgId: string;
-        userName: string | null;
-    }>, Record<never, never>, Record<never, never>>;
-};

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

@@ -1,307 +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;
-    comment_id: string;
-}, {
-    work_item_id: string;
-    comment_id: string;
-}>, Record<never, never>, Record<never, never>>;

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

@@ -1,98 +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 FIRST 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 first
- * 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, "id" | "content" | "created_at"> | null): {
-    work_item_id: string | null;
-    comment_id: string | null;
-    brief: string | null;
-    comment_created_at: string | null;
-    status: BriefReadStatus;
-};
-/**
- * Read the immutable FIRST comment on a work_items task. It is the launch brief;
- * later comments are conversation and must never change the launch identity.
- * Oldest-first by created_at with id as a deterministic tie-breaker. Returns null
- * when the task has no comment yet.
- */
-export declare function readFirstTaskComment(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;
-    comment_id: string | null;
-    brief: string | null;
-    comment_created_at: string | null;
-    status: BriefReadStatus;
-}, {
-    work_item_id: string | null;
-    comment_id: string | null;
-    brief: string | null;
-    comment_created_at: string | null;
-    status: BriefReadStatus;
-}>, Record<never, never>, Record<never, never>>;