@teamscala/service-boot 0.23.317 → 0.23.319

package/src/fn-routers/public-assessment-router.d.ts

@@ -1,68 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- * @edit edit directly
- *
- * Public ORPC procedure for submitting a public assessment (quiz) response.
- * Mirrors public-gpt-session-router: a public, system-trusted write path for an
- * anonymous/guest visitor — find-or-create the contact in client_database, score
- * the answers, and persist an assessment_responses row. This is the submit path
- * the deleted public-assessment wrapper used to provide via an injected onSubmit;
- * recovering it here brings the quiz in line with the shared machinery (the GPT's
- * publicGptSession is the sibling pattern) instead of a per-page bespoke handler.
- *
- * Scoring (recovered from live data, 2026-06-13): each scale answer contributes
- * (scaleValue - 1) earned out of 4 max (1–5 scale → 0–4); choice answers
- * contribute the selected option's points out of the question's max option
- * points. A category's score is round(100 * earned / max) over that category's
- * questions; the overall total is the same over all questions. Unanswered
- * questions count toward the denominator (contribute 0) — matches the historical
- * rows (e.g. Σ(v-1)=78 over 36 questions → 78/144 = 54).
- */
-import * as v from "valibot";
-interface Context {
-    prisma: any;
-    headers: Headers;
-    resolveUser?: (headers: Headers, prisma: any) => Promise<any>;
-}
-export declare const publicAssessmentRouter: {
-    submit: import("@orpc/server").DecoratedProcedure<Context & Record<never, never>, Context, v.ObjectSchema<{
-        readonly assessmentId: v.StringSchema<undefined>;
-        readonly firstName: v.StringSchema<undefined>;
-        readonly email: v.StringSchema<undefined>;
-        readonly company: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        readonly phone: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        readonly website: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        readonly industry: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        readonly teamSize: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        readonly revenueRange: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        readonly answers: v.ArraySchema<v.ObjectSchema<{
-            readonly questionId: v.StringSchema<undefined>;
-            readonly scaleValue: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-            readonly textValue: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-            readonly choiceValue: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-            readonly choiceValues: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
-        }, undefined>, undefined>;
-    }, undefined>, import("@orpc/contract").Schema<{
-        readonly error: "Assessment not found";
-    } | {
-        readonly error?: undefined;
-        success: true;
-        responseId: any;
-        reportUrl: string;
-        totalScore: number;
-        categoryScores: Record<string, number>;
-        band?: string | undefined;
-    }, {
-        readonly error: "Assessment not found";
-    } | {
-        readonly error?: undefined;
-        success: true;
-        responseId: any;
-        reportUrl: string;
-        totalScore: number;
-        categoryScores: Record<string, number>;
-        band?: string | undefined;
-    }>, Record<never, never>, Record<never, never>>;
-};
-export {};

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,276 +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";
-/**
- * The assignment input. `name` + `description` are REQUIRED TOGETHER at the
- * signature: oRPC parses this schema before the handler runs, so a call missing
- * either is rejected with a 400 — an incomplete task is unconstructible, not
- * caught after the fact. `description` becomes the task's first comment (the
- * brief); it is never stored separately on the task, so "the brief" has exactly
- * one home (`task-sync-brief.ts` readLatestTaskComment, newest-first).
- *
- * `name` → work_items.title; `description` → the first comment. `parent_id` is
- * the project the dispatched task is scoped under (omit for an exploratory
- * lane). `slug`/`windowName` shape the spawn; `organisation_id` defaults to the
- * platform org (fleet/internal lane tasks live there).
- */
-export declare const assignTaskInput: v.ObjectSchema<{
-    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, "name is required — an incomplete task is unconstructible">]>;
-    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.
- *
- * Refuses to STEAL a task another live session already owns — that is the
- * existing-session re-bind branch's job (matched by `kind_data.lane.session`).
- * Here we adopt only tasks with no session (or already this session). Returns
- * null when `maybeTaskId` is absent, not a task, or already owned by another
- * session — caller falls through to the normal create.
- */
-export declare function adoptAssignmentTask(prisma: Prisma, maybeTaskId: string | null | undefined, lane: {
-    session: string;
-    pane: string | null;
-    cli_kind?: string;
-    role?: string;
-}): Promise<WorkItem | null>;
-/**
- * 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 work label">]>;
-    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,69 +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";
-/**
- * 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. A null
- * task or null comment returns all-null rather than an empty/fake brief, so the
- * extension can distinguish "nothing to inject" from "inject this".
- */
-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;
-};
-/**
- * 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;
-}, {
-    work_item_id: string | null;
-    brief: string | null;
-    comment_created_at: string | null;
-}>, Record<never, never>, Record<never, never>>;