@owlmeans/viable-common 0.0.24 → 0.0.26

package/src/blueprint/case.ts

@@ -2,6 +2,7 @@ import { SubProject } from '../slot/consts.js'
 import { ViableSkill } from '../skills/consts.js'
 import { ViablePersona } from '../skills/roles.js'
 import { aiLibraryList, gameLibraryList } from '../skills/catalogue.js'
+import { LandingGatePreference } from './types.js'
 import type { BlueprintPatch } from './types.js'
 
 /**
@@ -61,8 +62,8 @@ export interface BlueprintCaseDefinition {
 /** What every AI case installs. The langchain peers are declared here, at ONE range. */
 const AI_DEPS = {
   [SubProject.Backend]: {
-    '@owlmeans/llm': '^0.1.18-rc.29',
-    '@owlmeans/agent': '^0.1.18-rc.30',
+    '@owlmeans/llm': '^0.1.18-rc.31',
+    '@owlmeans/agent': '^0.1.18-rc.32',
     '@langchain/core': '^1.2.9',
     '@langchain/anthropic': '^1.5.8',
     '@langchain/openai': '^1.5.10',
@@ -85,12 +86,6 @@ const AI_SKILLS = [
   ViableSkill.LibrariesAi,
 ]
 
-/**
- * What the analysis stage is told about a product whose value is a model.
- *
- * The pairing rule is the load-bearing one: an agent holds no permissions and owns no screen, so
- * a story that is the AGENT's work is invisible unless a human story starts it and watches it.
- */
 /**
  * What the API side is told once a project may have a queue.
  *
@@ -105,6 +100,12 @@ const PRODUCER_PERSONA_SKILLS = {
   [ViablePersona.ApiCoder]: [ViableSkill.WorkerJobs],
 }
 
+/**
+ * What the analysis stage is told about a product whose value is a model.
+ *
+ * The pairing rule is the load-bearing one: an agent holds no permissions and owns no screen, so
+ * a story that is the AGENT's work is invisible unless a human story starts it and watches it.
+ */
 const AI_PERSONA_SKILLS = {
   ...PRODUCER_PERSONA_SKILLS,
   [ViablePersona.BusinessAnalyst]: [ViableSkill.AgenticChoice],
@@ -115,6 +116,46 @@ const AI_PERSONA_SKILLS = {
   ],
 }
 
+type PersonaSkills = Partial<Record<ViablePersona, ViableSkill[]>>
+
+/**
+ * Join persona-skill maps, UNIONING a persona two maps both name.
+ *
+ * An object spread would keep only the last map's list for that persona — `BusinessAnalyst`
+ * carries `AgenticChoice` in an AI case and `LandingGate` from the gate map, and a spread would
+ * silently drop whichever came first.
+ */
+const joinPersonaSkills = (...maps: PersonaSkills[]): PersonaSkills => {
+  const out: PersonaSkills = {}
+  for (const map of maps) {
+    for (const [persona, skills] of Object.entries(map)) {
+      const key = persona as ViablePersona
+      out[key] = [...new Set([...(out[key] ?? []), ...(skills ?? [])])]
+    }
+  }
+
+  return out
+}
+
+/**
+ * Who has to know the landing-gate pattern in a case that encourages one.
+ *
+ * The analyst decides whether a story is gate-worthy and plans the gate's copy; the UX designer
+ * shapes the full-scale screen that continues what the guest started; the frontend personas draw
+ * the gate, write the handoff and read it back. Nobody else touches it.
+ */
+const LANDING_GATE_PERSONA_SKILLS: PersonaSkills = {
+  [ViablePersona.BusinessAnalyst]: [ViableSkill.LandingGate],
+  [ViablePersona.UxDesigner]: [ViableSkill.LandingGate],
+  [ViablePersona.LayoutArchitect]: [ViableSkill.LandingGate],
+  [ViablePersona.ComponentArchitect]: [ViableSkill.LandingGate],
+  [ViablePersona.UiViewCoder]: [ViableSkill.LandingGate],
+  [ViablePersona.UiNavCoder]: [ViableSkill.LandingGate],
+}
+
+/** The experience layer of a case whose product usually has a step a guest can begin. */
+const ENCOURAGE_GATE = { landingGate: LandingGatePreference.Encourage }
+
 const GAME_PERSONA_SKILLS = {
   [ViablePersona.BusinessAnalyst]: [ViableSkill.GameDesign],
   [ViablePersona.UxDesigner]: [ViableSkill.GameDesign, ViableSkill.GameUi],
@@ -151,7 +192,9 @@ party, nothing walks an unbounded set, nothing is scheduled. Most products are t
     patch: {
       packages: {
         capabilities: { postgres: true, kv: false, queue: false, worker: false, agents: false, validation: true },
+        personaSkills: LANDING_GATE_PERSONA_SKILLS,
       },
+      experience: ENCOURAGE_GATE,
     },
   },
 
@@ -173,6 +216,9 @@ to call a model at all.
         capabilities: { postgres: true, kv: true, queue: true, worker: true, agents: false, validation: true },
         personaSkills: PRODUCER_PERSONA_SKILLS,
       },
+      // Neutral: the named off-request part is usually operator-side work, and whether a guest
+      // can begin anything is the specification's to say.
+      experience: { landingGate: LandingGatePreference.Allow },
     },
   },
 
@@ -194,8 +240,9 @@ application, and never merely a scalable one.
         deps: AI_DEPS,
         libraries: AI_LIBRARIES,
         skills: AI_SKILLS,
-        personaSkills: AI_PERSONA_SKILLS,
+        personaSkills: joinPersonaSkills(AI_PERSONA_SKILLS, LANDING_GATE_PERSONA_SKILLS),
       },
+      experience: ENCOURAGE_GATE,
     },
   },
 
@@ -214,18 +261,16 @@ in advance.
         deps: {
           [SubProject.Backend]: {
             ...AI_DEPS[SubProject.Backend],
-            '@owlmeans/agent-skills': '^0.1.18-rc.28',
+            '@owlmeans/agent-skills': '^0.1.18-rc.31',
           },
         },
         libraries: AI_LIBRARIES,
         skills: [...AI_SKILLS, ViableSkill.TargetAgentTools],
-        personaSkills: {
-          ...AI_PERSONA_SKILLS,
-          [ViablePersona.WorkerCoder]: [
-            ...AI_PERSONA_SKILLS[ViablePersona.WorkerCoder], ViableSkill.TargetAgentTools,
-          ],
-        },
+        personaSkills: joinPersonaSkills(AI_PERSONA_SKILLS, LANDING_GATE_PERSONA_SKILLS, {
+          [ViablePersona.WorkerCoder]: [ViableSkill.TargetAgentTools],
+        }),
       },
+      experience: ENCOURAGE_GATE,
     },
   },
 
@@ -248,6 +293,9 @@ is not it.
         skills: [ViableSkill.GameScene, ViableSkill.GameUi, ViableSkill.LibrariesGame],
         personaSkills: { ...PRODUCER_PERSONA_SKILLS, ...GAME_PERSONA_SKILLS },
       },
+      // A game's first value is PLAYING it, and the play screen is its own front door — a
+      // pick-and-preview card on a landing page is the wrong shape for it.
+      experience: { landingGate: LandingGatePreference.Discourage },
     },
   },
 }

package/src/blueprint/resolve.ts

@@ -54,6 +54,9 @@ export const freezeBlueprint = (blueprint: Blueprint): Blueprint => Object.freez
     ...blueprint.packages,
     capabilities: Object.freeze({ ...blueprint.packages.capabilities }),
   }),
+  // The one optional layer: frozen when present, and never ADDED when absent, so a blueprint that
+  // has none still compares equal to what it was before the layer existed.
+  ...(blueprint.experience != null ? { experience: Object.freeze({ ...blueprint.experience }) } : {}),
 })
 
 /** Every skill the blueprint asks for, stack first, deduped, order preserved. */

package/src/blueprint/types.ts

@@ -16,6 +16,12 @@ import type { TopologyDescriptor } from '../topology/types.js'
  * Deliberately NOT called a preset: `presets/` in the agent library already means the LLM
  * model/provider configurations, and the two are asked at different moments about different
  * things.
+ *
+ * Five layers are REQUIRED and say what the project is built WITH; the sixth, `experience`, is
+ * OPTIONAL and says what its product should do for the people using it. Optional because a
+ * blueprint registered before the layer existed — or a patch serialized into a run row — must keep
+ * resolving: every reader asks through a helper that answers the default for an absent layer
+ * ({@link landingGatePreferenceOf}).
  */
 export interface Blueprint {
   id: string
@@ -25,6 +31,7 @@ export interface Blueprint {
   template: TemplateLayer
   createApp: CreateAppLayer
   packages: PackagesLayer
+  experience?: ExperienceLayer
 }
 
 /**
@@ -32,7 +39,8 @@ export interface Blueprint {
  *
  * The ordering is the point: `technology` overrides everything, because a change of language
  * invalidates every template, prompt and package below it. Nothing today has more than one
- * technology — the ladder exists so that adding one is a data change.
+ * technology — the ladder exists so that adding one is a data change. `experience` is last and
+ * optional: it shares no key with the five build layers, so its place decides nothing today.
  */
 export enum BlueprintLayer {
   Technology = 'technology',
@@ -40,6 +48,7 @@ export enum BlueprintLayer {
   Template = 'template',
   CreateApp = 'create-app',
   Packages = 'packages',
+  Experience = 'experience',
 }
 
 export const BLUEPRINT_LAYER_ORDER: BlueprintLayer[] = [
@@ -48,8 +57,55 @@ export const BLUEPRINT_LAYER_ORDER: BlueprintLayer[] = [
   BlueprintLayer.Template,
   BlueprintLayer.CreateApp,
   BlueprintLayer.Packages,
+  BlueprintLayer.Experience,
 ]
 
+/**
+ * How strongly a product of this kind wants a LANDING GATE — the working entry into the key
+ * end-user workflow drawn on the guest home, where a guest starts before signing in.
+ *
+ * A PRIOR handed to the model that decides, never the decision itself: `Encourage` still lets it
+ * answer "no gate" for a product with no end-user step a guest could begin, and `Discourage` still
+ * lets it choose one when the specification plainly describes such a step.
+ */
+export enum LandingGatePreference {
+  /** Most products of this kind have a first-value step a guest can begin — look for it. */
+  Encourage = 'encourage',
+  /** Neutral: decide from the specification alone. */
+  Allow = 'allow',
+  /** Products of this kind rarely have one — choose a gate only when the specification asks. */
+  Discourage = 'discourage',
+}
+
+/**
+ * What the product should do for the people using it, independent of the stack it is built on.
+ *
+ * A layer of its own rather than a field of `packages`, because it changes no dependency, no
+ * capability and no prompt a coder reads — it is asked by the analysis stage about the PRODUCT.
+ */
+export interface ExperienceLayer {
+  landingGate: LandingGatePreference
+}
+
+const LANDING_GATE_PREFERENCES = new Set<string>(Object.values(LandingGatePreference))
+
+/**
+ * The landing-gate preference of a resolved blueprint.
+ *
+ * Total: an absent layer, an absent key and a value this deploy does not know (a patch serialized
+ * by a newer one) all answer `Allow` — the neutral prior, which leaves the decision to the
+ * specification rather than tilting it either way on a value nobody set.
+ */
+export const landingGatePreferenceOf = (
+  blueprint?: Pick<Blueprint, 'experience'> | null
+): LandingGatePreference => {
+  const value = blueprint?.experience?.landingGate
+
+  return value != null && LANDING_GATE_PREFERENCES.has(value)
+    ? value
+    : LandingGatePreference.Allow
+}
+
 /** Language and toolchain. Overrides everything below it. */
 export interface TechnologyLayer {
   id: string

package/src/branding.ts

@@ -14,6 +14,7 @@ export const BRANDING_ENV_KEYS = [
   'BRANDING_PRIVACY_URL',
   'BRANDING_CREDIT',
   'BRANDING_PRODUCT',
+  'BRANDING_GOOGLE_TAG',
 ] as const
 
 /**
@@ -23,6 +24,10 @@ export const BRANDING_ENV_KEYS = [
  * hides the platform credit, so a metadata set that never carried the key keeps it. That is the
  * safe direction — the opposite failure hands out a paid feature and nobody reports getting more
  * than they paid for.
+ *
+ * `BRANDING_GOOGLE_TAG` is always EMITTED, empty when no tag is set, although its metadata key is
+ * omitted from a push while unset: the environment is read by the application's own build, which
+ * treats `''` as "load no tag", while the metadata key is read by a publisher that may predate it.
  */
 export const brandingEnv = (meta: Partial<SlotMetadata>): Record<string, string> => ({
   BRANDING_COPYRIGHT: meta.brandingCopyright ?? '',
@@ -31,4 +36,5 @@ export const brandingEnv = (meta: Partial<SlotMetadata>): Record<string, string>
   BRANDING_PRIVACY_URL: meta.brandingPrivacyUrl ?? '',
   BRANDING_CREDIT: meta.brandingCredit === '' ? '' : '1',
   BRANDING_PRODUCT: meta.projectName ?? '',
+  BRANDING_GOOGLE_TAG: meta.brandingGoogleTag ?? '',
 })

package/src/connect/consts.ts

@@ -209,47 +209,12 @@ export enum ModelTaskRole {
   Tool = 'tool',
 }
 
-/** The KIND of thing a job is, so a parent can be told what it is waiting for. */
-export enum ConnectJobKind {
-  ProjectCreate = 'project-create',
-  ProjectInit = 'project-init',
-  ProjectReinit = 'project-reinit',
-  StoryDevelop = 'story-develop',
-  FreeFlight = 'free-flight',
-  PipelineResume = 'pipeline-resume',
-  /**
-   * The four stages of a conversion, plus the purge.
-   *
-   * One kind per stage rather than one for the whole conversion: each stage is its own platform
-   * pipeline run, ends at a decision the user makes, and is looked up by the pipeline alias its
-   * kind names. A single `convert` kind would match whichever run row happened to be newest.
-   */
-  ConvertIntake = 'convert-intake',
-  ConvertAnalysis = 'convert-analysis',
-  ConvertExtraction = 'convert-extraction',
-  ConvertImplementation = 'convert-implementation',
-  ConvertPurge = 'convert-purge',
-}
-
-export enum ConnectJobStatus {
-  Queued = 'queued',
-  Running = 'running',
-  /** Running, but waiting on the connector — see `ConnectJob.blockedOn`. */
-  Blocked = 'blocked',
-  Done = 'done',
-  Failed = 'failed',
-}
-
-/** What a blocked job is waiting for. */
-export enum ConnectJobBlock {
-  /** Model tasks are queued and nobody is answering them. */
+/** Why a domain operation cannot currently advance. */
+export enum ConnectWaitReason {
+  Person = 'person',
   ModelTask = 'model-task',
-  /** Slot commands are queued and no connector is attached. */
-  LocalOp = 'local-op',
-  /** The local target has no database configured and the run needs one. */
-  Env = 'env',
-  /** A question is waiting for a person and nobody has answered it. */
-  Question = 'question',
+  LocalConnector = 'local-connector',
+  Environment = 'environment',
 }
 
 /**
@@ -336,6 +301,19 @@ export const CONNECT_CONFIGURE_TIMEOUT_MS = 60_000
  */
 export const CONNECT_CAP_LOCAL_LLM_KEY = 'connect--local-llm'
 
+/**
+ * The ceilings of a project's branding strings on the connector wire.
+ *
+ * Each equals its twin in the platform's own branding contract (`BRANDING_COPYRIGHT_MAX`,
+ * `BRANDING_ORGANIZATION_MAX`, `BRANDING_URL_MAX`) and must stay equal: a connector refused below the
+ * web form's limit, or accepted above it and refused further in, is one value with two answers.
+ * The Google tag's is its own — the longest id any Google product issues is well under it.
+ */
+export const CONNECT_BRANDING_COPYRIGHT_MAX = 200
+export const CONNECT_BRANDING_ORGANIZATION_MAX = 120
+export const CONNECT_BRANDING_URL_MAX = 2048
+export const CONNECT_BRANDING_GOOGLE_TAG_MAX = 32
+
 /** The access-token prefix the platform issues. Every connector token starts with it. */
 export const CONNECT_TOKEN_PREFIX = 'vib_'
 
@@ -398,10 +376,8 @@ export const RES_CONNECT_SESSION = 'connect-session'
  * the tree would be a second place for a name to drift. The platform spreads the declarations
  * these produce into its own entrypoint list and binds handlers onto them.
  *
- * There is no story group. A user story is a planning CARD, read and written through the planning
- * protocol tree the platform mounts beside this one (`makePlanningProtocols` in
- * `@owlmeans/planning`) — one surface for the browser and a connector alike, so a story rule the
- * platform enforces cannot be enforced on one of them only.
+ * Story mutations use the planning CARD surface. The connector story status route composes that
+ * card with its pipeline run and pending inquiry without creating a second mutation path.
  */
 export const connect = Object.freeze({
   base: 'viable:manager-api:connect:base',
@@ -430,7 +406,18 @@ export const connect = Object.freeze({
     llm: 'viable:manager-api:connect:project:llm',
     /** The per-project converter inference mode. Separate from `llm`: it is not a paid capability. */
     converterLlm: 'viable:manager-api:connect:project:converter-llm',
-    job: 'viable:manager-api:connect:project:job',
+    /**
+     * The project's own branding — copyright, organization, the two legal links, the Google tag.
+     * The platform credit is deliberately NOT here: hiding it is a paid capability with its own
+     * gated route, and a connector setting the rest must never be able to touch it.
+     */
+    branding: Object.freeze({
+      get: 'viable:manager-api:connect:project:branding:get',
+      save: 'viable:manager-api:connect:project:branding:save',
+    }),
+  }),
+  story: Object.freeze({
+    status: 'viable:manager-api:connect:story:status',
   }),
   convert: Object.freeze({
     create: 'viable:manager-api:connect:convert:create',

package/src/connect/entrypoints.ts

@@ -6,16 +6,18 @@ import { connect } from './consts.js'
 import {
   ConnectAttachBodySchema, ConnectConfirmBodySchema, ConnectConvertCreateBodySchema,
   ConnectConvertProceedBodySchema, ConnectCreateBodySchema, ConnectInquiryParamsSchema,
-  ConnectJobParamsSchema, ConnectModifyBodySchema, ConnectOpParamsSchema, ConnectOpResultSchema,
-  ConnectPipelineParamsSchema, ConnectPipelineResumeBodySchema, ConnectProjectIdSchema,
-  ConnectProjectLlmBodySchema, ConnectSessionOpenSchema, ConnectSessionParamsSchema,
-  ConnectWaitQuerySchema, InquiryAnswerSchema,
+  ConnectModifyBodySchema, ConnectOpParamsSchema, ConnectOpResultSchema,
+  ConnectPipelineParamsSchema, ConnectPipelineResumeBodySchema, ConnectProjectBrandingSaveSchema,
+  ConnectProjectIdSchema, ConnectProjectLlmBodySchema, ConnectSessionOpenSchema,
+  ConnectSessionParamsSchema, ConnectPullQuerySchema, ConnectStoryParamsSchema, InquiryAnswerSchema,
 } from './schemas.js'
 import type {
   ConnectAttachBody, ConnectConfirmBody, ConnectConvertCreateBody, ConnectConvertProceedBody,
-  ConnectCreateBody, ConnectInquiryAnswerBody, ConnectJob, ConnectJobParams, ConnectModifyBody,
-  ConnectPipelineParams, ConnectPipelineResumeBody, ConnectProjectLlmBody, ConnectSessionOpen,
-  ConnectSessionParams, ConnectWaitQuery, ConversionStatusView, ConvertCheck,
+  ConnectCreateBody, ConnectInquiryAnswerBody, ConnectModifyBody,
+  ConnectPipelineParams, ConnectPipelineResumeBody, ConnectProjectBranding,
+  ConnectProjectBrandingSave, ConnectProjectLlmBody, ConnectSessionOpen,
+  ConnectPipelineState, ConnectProjectStatus, ConnectPullQuery, ConnectSessionParams,
+  ConnectStoryStatus, ConversionStatusView, ConvertCheck,
 } from './types.js'
 import type { ConnectOpResult } from './ops.js'
 import type { ConverterProjectLlmBody } from '../convert/types.js'
@@ -115,7 +117,7 @@ export const connectProtocols = (opts: ConnectEntrypointOptions) => {
       route(connect.op.pull, '/session/:sessionId/ops', {
         parent: base, method: RouteMethod.GET
       }),
-      contract.request({ params: typed<ConnectSessionParams>(ConnectSessionParamsSchema), query: typed<ConnectWaitQuery>(ConnectWaitQuerySchema) }, typed())
+      contract.request({ params: typed<ConnectSessionParams>(ConnectSessionParamsSchema), query: typed<ConnectPullQuery>(ConnectPullQuerySchema) }, typed())
     ),
     submit: protocol(
       route(connect.op.submit, '/session/:sessionId/ops/:opId', {
@@ -130,7 +132,7 @@ export const connectProtocols = (opts: ConnectEntrypointOptions) => {
     project: {
     create: protocol(
       route(connect.project.create, '/project', { parent: base, method: RouteMethod.POST }),
-      contract.request({ body: typed<ConnectCreateBody>(ConnectCreateBodySchema) }, typed())
+      contract.request({ body: typed<ConnectCreateBody>(ConnectCreateBodySchema) }, typed<ConnectProjectStatus>())
     ),
     list: protocol(
       route(connect.project.list, '/project', { parent: base, method: RouteMethod.GET }),
@@ -146,25 +148,25 @@ export const connectProtocols = (opts: ConnectEntrypointOptions) => {
       route(connect.project.confirm, '/project/:id/confirm', {
         parent: base, method: RouteMethod.POST
       }),
-      contract.request({ params: typed<{ id: string }>(ConnectProjectIdSchema), body: typed<ConnectConfirmBody>(ConnectConfirmBodySchema) }, typed())
+      contract.request({ params: typed<{ id: string }>(ConnectProjectIdSchema), body: typed<ConnectConfirmBody>(ConnectConfirmBodySchema) }, typed<ConnectProjectStatus>())
     ),
     status: protocol(
       route(connect.project.status, '/project/:id/status', {
         parent: base, method: RouteMethod.GET
       }),
-      contract.request({ params: typed<{ id: string }>(ConnectProjectIdSchema) }, typed())
+      contract.request({ params: typed<{ id: string }>(ConnectProjectIdSchema) }, typed<ConnectProjectStatus>())
     ),
     reinit: protocol(
       route(connect.project.reinit, '/project/:id/reinit', {
         parent: base, method: RouteMethod.POST
       }),
-      contract.request({ params: typed<{ id: string }>(ConnectProjectIdSchema) }, typed())
+      contract.request({ params: typed<{ id: string }>(ConnectProjectIdSchema) }, typed<ConnectProjectStatus>())
     ),
     modify: protocol(
       route(connect.project.modify, '/project/:id/modify', {
         parent: base, method: RouteMethod.POST
       }),
-      contract.request({ params: typed<{ id: string }>(ConnectProjectIdSchema), body: typed<ConnectModifyBody>(ConnectModifyBodySchema) }, typed())
+      contract.request({ params: typed<{ id: string }>(ConnectProjectIdSchema), body: typed<ConnectModifyBody>(ConnectModifyBodySchema) }, typed<ConnectProjectStatus>())
     ),
     settings: protocol(
       route(connect.project.settings, '/project/:id/settings', {
@@ -187,11 +189,37 @@ export const connectProtocols = (opts: ConnectEntrypointOptions) => {
         body: typed<ConverterProjectLlmBody>(ConverterProjectLlmBodySchema),
       }, typed()),
     ),
-    job: protocol(
-      route(connect.project.job, '/project/:id/job/:jobId', {
+    // Under `base` like every sibling — the guard and the ownership gate — and never under the
+    // paid gate: saving branding is free, and the paid credit switch is not reachable from here.
+    branding: {
+      get: protocol(
+        route(connect.project.branding.get, '/project/:id/branding', {
+          parent: base, method: RouteMethod.GET,
+        }),
+        contract.request({
+          params: typed<{ id: string }>(ConnectProjectIdSchema),
+        }, typed<ConnectProjectBranding>()),
+      ),
+      save: protocol(
+        route(connect.project.branding.save, '/project/:id/branding', {
+          parent: base, method: RouteMethod.POST,
+        }),
+        contract.request({
+          params: typed<{ id: string }>(ConnectProjectIdSchema),
+          body: typed<ConnectProjectBrandingSave>(ConnectProjectBrandingSaveSchema),
+        }, typed<ConnectProjectBranding>()),
+      ),
+    },
+    },
+
+    story: {
+    status: protocol(
+      route(connect.story.status, '/project/:id/story/:storyId/status', {
         parent: base, method: RouteMethod.GET
       }),
-      contract.request({ params: typed<ConnectJobParams>(ConnectJobParamsSchema), query: typed<ConnectWaitQuery>(ConnectWaitQuerySchema) }, typed())
+      contract.request({
+        params: typed<{ id: string, storyId: string }>(ConnectStoryParamsSchema),
+      }, typed<ConnectStoryStatus>())
     ),
 
     },
@@ -207,7 +235,7 @@ export const connectProtocols = (opts: ConnectEntrypointOptions) => {
     convert: {
     create: protocol(
       route(connect.convert.create, '/convert', { parent: base, method: RouteMethod.POST }),
-      contract.request({ body: typed<ConnectConvertCreateBody>(ConnectConvertCreateBodySchema) }, typed<ConnectJob>()),
+      contract.request({ body: typed<ConnectConvertCreateBody>(ConnectConvertCreateBodySchema) }, typed<ConversionStatusView>()),
     ),
     check: protocol(
       route(connect.convert.check, '/convert/:id/check', { parent: base, method: RouteMethod.GET }),
@@ -215,18 +243,18 @@ export const connectProtocols = (opts: ConnectEntrypointOptions) => {
     ),
     start: protocol(
       route(connect.convert.start, '/convert/:id/start', { parent: base, method: RouteMethod.POST }),
-      contract.request({ params: typed<{ id: string }>(ConnectProjectIdSchema) }, typed<ConnectJob>()),
+      contract.request({ params: typed<{ id: string }>(ConnectProjectIdSchema) }, typed<ConversionStatusView>()),
     ),
     proceed: protocol(
       route(connect.convert.proceed, '/convert/:id/proceed', { parent: base, method: RouteMethod.POST }),
       contract.request({
         params: typed<{ id: string }>(ConnectProjectIdSchema),
         body: typed<ConnectConvertProceedBody>(ConnectConvertProceedBodySchema),
-      }, typed<ConnectJob>()),
+      }, typed<ConversionStatusView>()),
     ),
     cancel: protocol(
       route(connect.convert.cancel, '/convert/:id/cancel', { parent: base, method: RouteMethod.POST }),
-      contract.request({ params: typed<{ id: string }>(ConnectProjectIdSchema) }, typed<ConnectJob>()),
+      contract.request({ params: typed<{ id: string }>(ConnectProjectIdSchema) }, typed<ConversionStatusView>()),
     ),
     status: protocol(
       route(connect.convert.status, '/convert/:id', { parent: base, method: RouteMethod.GET }),
@@ -234,7 +262,7 @@ export const connectProtocols = (opts: ConnectEntrypointOptions) => {
     ),
     purge: protocol(
       route(connect.convert.purge, '/convert/:id/purge', { parent: base, method: RouteMethod.POST }),
-      contract.request({ params: typed<{ id: string }>(ConnectProjectIdSchema) }, typed<ConnectJob>()),
+      contract.request({ params: typed<{ id: string }>(ConnectProjectIdSchema) }, typed<ConversionStatusView>()),
     ),
     },
 
@@ -256,13 +284,13 @@ export const connectProtocols = (opts: ConnectEntrypointOptions) => {
       route(connect.pipeline.state, '/pipeline/:id/:runId', {
         parent: base, method: RouteMethod.GET
       }),
-      contract.request({ params: typed<ConnectPipelineParams>(ConnectPipelineParamsSchema) }, typed())
+      contract.request({ params: typed<ConnectPipelineParams>(ConnectPipelineParamsSchema) }, typed<ConnectPipelineState>())
     ),
     resume: protocol(
       route(connect.pipeline.resume, '/pipeline/:id/:runId/resume', {
         parent: base, method: RouteMethod.POST
       }),
-      contract.request({ params: typed<ConnectPipelineParams>(ConnectPipelineParamsSchema), body: typed<ConnectPipelineResumeBody>(ConnectPipelineResumeBodySchema) }, typed())
+      contract.request({ params: typed<ConnectPipelineParams>(ConnectPipelineParamsSchema), body: typed<ConnectPipelineResumeBody>(ConnectPipelineResumeBodySchema) }, typed<ConnectPipelineState>())
     ),
     },
   }

package/src/connect/index.ts

@@ -3,6 +3,5 @@ export * from './schemas.js'
 export * from './errors.js'
 export * from './entrypoints.js'
 export * from './references.js'
-export * from './jobs.js'
 export type * from './types.js'
 export type * from './ops.js'

package/src/connect/ops.ts

@@ -91,8 +91,6 @@ export interface ConfigureResult {
 export interface ModelTask {
   id: string
   projectId: string
-  /** The job the call belongs to, so a parent can say what it is working on. */
-  jobId?: string
   /** The platform role that asked. Informational; the tier is what decides the model. */
   role: string
   tier: ModelTier
@@ -170,14 +168,13 @@ export interface ConnectInquiryOption {
 /**
  * One question put to the person the connector is working for.
  *
- * It carries where it came from — the job, the run and the step — because an answer is recorded
+ * It carries where it came from — the run and the step — because an answer is recorded
  * against the run that asked and re-read when that run resumes. `expiresAt` is what makes an
  * unanswered question fail its step instead of parking a project lock forever.
  */
 export interface InquiryPayload {
   id: string
   projectId: string
-  jobId?: string
   runId?: string
   /** The pipeline step that asked, so a resumed run can match the answer to the place it belongs. */
   step?: string