@owlmeans/viable-common 0.0.4

package/build/skills/catalogue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalogue.js","sourceRoot":"","sources":["../../src/skills/catalogue.ts"],"names":[],"mappings":"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"}

package/build/skills/consts.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Aliases of the skills viable registers on the prompt service.
+ *
+ * A skill is a named, reusable block of system-prompt knowledge. Roles reference these
+ * aliases instead of pasting the text, which is what stopped the same entrypoint and
+ * resource-layer rules from living in four different helper files at once.
+ */
+export declare enum ViableSkill {
+    /** Answer with source code and nothing else. */
+    OutputSourceOnly = "output-source-only",
+    /** Answer with prose and nothing else. */
+    OutputTextOnly = "output-text-only",
+    /** Build only what was asked for. */
+    ScopeDiscipline = "scope-discipline",
+    /** One key user, one shortest path to value — for every analysis-stage helper. */
+    MainFlowFocus = "main-flow-focus",
+    /** Overrides the TypeScript rules for a file that is not TypeScript. */
+    NonTypescriptOutput = "non-typescript-output",
+    TsStyle = "ts-style",
+    TsImports = "ts-imports",
+    ReactComponents = "react-components",
+    OwlMeansEntrypoints = "owlmeans-entrypoints",
+    OwlMeansNav = "owlmeans-nav",
+    /** How one permission has to line up across the gate, the definition and the grant. */
+    PermissionModel = "permission-model",
+    ShadcnUi = "shadcn-ui",
+    OwlmeansState = "owlmeans-state",
+    /** What an action says when it worked, what it says when it did not, and where it leaves you. */
+    FormFeedback = "form-feedback",
+    StoreAccess = "store-access",
+    ViewModelNaming = "viewmodel-naming",
+    ResourceLayer = "resource-layer",
+    ResourceResults = "resource-results",
+    ResourceMigrations = "resource-migrations",
+    OwlMeansServer = "owlmeans-server",
+    OwlmeansContext = "owlmeans-context",
+    OwlMeansServices = "owlmeans-services",
+    FixerHeuristics = "fixer-heuristics",
+    ProjectLayout = "project-layout",
+    AgentTooling = "agent-tooling",
+    /** When work belongs off the request path — and, far more often, when it does not. */
+    QueueDiscipline = "queue-discipline",
+    /** Writing a queue declaration, a job entrypoint and a processor that agree. */
+    WorkerJobs = "worker-jobs",
+    /** Generating an @owlmeans/agent agent or pipeline INTO the application. */
+    TargetAgents = "target-agents",
+    /** Whether a model call, a fixed pipeline or a tool-using agent is the right shape. */
+    AgenticChoice = "agentic-choice",
+    /** Making a single model call from inside the generated application. */
+    TargetLlm = "target-llm",
+    /** Giving the application's own agent its tools and its own installed skills. */
+    TargetAgentTools = "target-agent-tools",
+    /** What a game brief is made of, and what it is not. */
+    GameDesign = "game-design",
+    /** The three.js scene component — renderer, camera, loop, disposal. */
+    GameScene = "game-scene",
+    /** Every control is an ordinary React component ABOVE the canvas, never inside it. */
+    GameUi = "game-ui",
+    /** Casual, turn-based online and live online — and who owns the state in each. */
+    GameNetworking = "game-networking",
+    LayoutDefinition = "layout-definition",
+    ScreenDefinition = "screen-definition",
+    LibrariesCommon = "libraries-common",
+    LibrariesUiState = "libraries-ui-state",
+    LibrariesUi = "libraries-ui",
+    LibrariesBackend = "libraries-backend",
+    LibrariesAi = "libraries-ai",
+    LibrariesGame = "libraries-game"
+}
+/**
+ * Sort weights. Skills render in this order inside the cached block, so the sequence is
+ * part of the cache key — reordering them invalidates every prefix at once. Grouped in
+ * tens to leave room for a consumer's own skills between them.
+ */
+export declare const SKILL_ORDER: Record<ViableSkill, number>;
+/**
+ * The catalogue entries whose subject a PUBLISHED `@owlmeans` package already documents.
+ *
+ * The catalogue and `agent-meta/skills/*` state the same contract twice — the P1 duplication —
+ * and the duplication is not symmetric: a package skill is versioned with the package and reaches
+ * a prompt through `owlmeansPackagesPlugin` whenever the request names that package, while a
+ * catalogue entry is a constant here that has to be edited by hand every time the framework moves.
+ *
+ * Naming the overlap is what makes it a DATA decision instead of a code one. A blueprint lists
+ * which of these its prompts carry, and a persona's skills are filtered against that list — so
+ * dropping one is a line in a blueprint, and restoring it is the same line. Everything NOT in this
+ * set is viable's own (output discipline, scope, the view-model convention, the fixer heuristics,
+ * where files live) and always loads, because no published package documents it.
+ *
+ * The default blueprint currently lists every one of them: the reduction is a real change to what
+ * a coder is told, and it is measured against a green end-to-end baseline rather than guessed.
+ */
+export declare const FRAMEWORK_OWNED_SKILLS: ViableSkill[];
+/**
+ * Filter a persona's skills against what a blueprint asks for.
+ *
+ * A skill nobody owns always survives. A framework-owned one survives only while the blueprint
+ * lists it — so a blueprint built on another persistence layer stops teaching the Postgres
+ * resource contract without anybody editing a persona, and a blueprint that lists nothing at all
+ * (the shape a test builds) is read as "everything", because an empty allow-list almost always
+ * means "not stated" rather than "none".
+ */
+export declare const skillsForBlueprint: (skills: ViableSkill[], allowed?: ViableSkill[]) => ViableSkill[];
+//# sourceMappingURL=consts.d.ts.map

package/build/skills/consts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consts.d.ts","sourceRoot":"","sources":["../../src/skills/consts.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,oBAAY,WAAW;IACrB,gDAAgD;IAChD,gBAAgB,uBAAuB;IACvC,0CAA0C;IAC1C,cAAc,qBAAqB;IACnC,qCAAqC;IACrC,eAAe,qBAAqB;IACpC,kFAAkF;IAClF,aAAa,oBAAoB;IACjC,wEAAwE;IACxE,mBAAmB,0BAA0B;IAE7C,OAAO,aAAa;IACpB,SAAS,eAAe;IAExB,eAAe,qBAAqB;IACpC,mBAAmB,yBAAyB;IAC5C,WAAW,iBAAiB;IAC5B,uFAAuF;IACvF,eAAe,qBAAqB;IACpC,QAAQ,cAAc;IACtB,aAAa,mBAAmB;IAChC,iGAAiG;IACjG,YAAY,kBAAkB;IAC9B,WAAW,iBAAiB;IAC5B,eAAe,qBAAqB;IAEpC,aAAa,mBAAmB;IAChC,eAAe,qBAAqB;IACpC,kBAAkB,wBAAwB;IAC1C,cAAc,oBAAoB;IAClC,eAAe,qBAAqB;IACpC,gBAAgB,sBAAsB;IACtC,eAAe,qBAAqB;IAEpC,aAAa,mBAAmB;IAChC,YAAY,kBAAkB;IAE9B,sFAAsF;IACtF,eAAe,qBAAqB;IACpC,gFAAgF;IAChF,UAAU,gBAAgB;IAC1B,4EAA4E;IAC5E,YAAY,kBAAkB;IAE9B,uFAAuF;IACvF,aAAa,mBAAmB;IAChC,wEAAwE;IACxE,SAAS,eAAe;IACxB,iFAAiF;IACjF,gBAAgB,uBAAuB;IAEvC,wDAAwD;IACxD,UAAU,gBAAgB;IAC1B,uEAAuE;IACvE,SAAS,eAAe;IACxB,sFAAsF;IACtF,MAAM,YAAY;IAClB,kFAAkF;IAClF,cAAc,oBAAoB;IAElC,gBAAgB,sBAAsB;IACtC,gBAAgB,sBAAsB;IAEtC,eAAe,qBAAqB;IACpC,gBAAgB,uBAAuB;IACvC,WAAW,iBAAiB;IAC5B,gBAAgB,sBAAsB;IACtC,WAAW,iBAAiB;IAC5B,aAAa,mBAAmB;CACjC;AAED;;;;GAIG;AACH,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,WAAW,EAAE,MAAM,CA4CnD,CAAA;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,sBAAsB,EAAE,WAAW,EAe/C,CAAA;AAID;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,WACrB,WAAW,EAAE,YAAY,WAAW,EAAE,KAC7C,WAAW,EAKb,CAAA"}

package/build/skills/consts.js

@@ -0,0 +1,170 @@
+/**
+ * Aliases of the skills viable registers on the prompt service.
+ *
+ * A skill is a named, reusable block of system-prompt knowledge. Roles reference these
+ * aliases instead of pasting the text, which is what stopped the same entrypoint and
+ * resource-layer rules from living in four different helper files at once.
+ */
+export var ViableSkill;
+(function (ViableSkill) {
+    /** Answer with source code and nothing else. */
+    ViableSkill["OutputSourceOnly"] = "output-source-only";
+    /** Answer with prose and nothing else. */
+    ViableSkill["OutputTextOnly"] = "output-text-only";
+    /** Build only what was asked for. */
+    ViableSkill["ScopeDiscipline"] = "scope-discipline";
+    /** One key user, one shortest path to value — for every analysis-stage helper. */
+    ViableSkill["MainFlowFocus"] = "main-flow-focus";
+    /** Overrides the TypeScript rules for a file that is not TypeScript. */
+    ViableSkill["NonTypescriptOutput"] = "non-typescript-output";
+    ViableSkill["TsStyle"] = "ts-style";
+    ViableSkill["TsImports"] = "ts-imports";
+    ViableSkill["ReactComponents"] = "react-components";
+    ViableSkill["OwlMeansEntrypoints"] = "owlmeans-entrypoints";
+    ViableSkill["OwlMeansNav"] = "owlmeans-nav";
+    /** How one permission has to line up across the gate, the definition and the grant. */
+    ViableSkill["PermissionModel"] = "permission-model";
+    ViableSkill["ShadcnUi"] = "shadcn-ui";
+    ViableSkill["OwlmeansState"] = "owlmeans-state";
+    /** What an action says when it worked, what it says when it did not, and where it leaves you. */
+    ViableSkill["FormFeedback"] = "form-feedback";
+    ViableSkill["StoreAccess"] = "store-access";
+    ViableSkill["ViewModelNaming"] = "viewmodel-naming";
+    ViableSkill["ResourceLayer"] = "resource-layer";
+    ViableSkill["ResourceResults"] = "resource-results";
+    ViableSkill["ResourceMigrations"] = "resource-migrations";
+    ViableSkill["OwlMeansServer"] = "owlmeans-server";
+    ViableSkill["OwlmeansContext"] = "owlmeans-context";
+    ViableSkill["OwlMeansServices"] = "owlmeans-services";
+    ViableSkill["FixerHeuristics"] = "fixer-heuristics";
+    ViableSkill["ProjectLayout"] = "project-layout";
+    ViableSkill["AgentTooling"] = "agent-tooling";
+    /** When work belongs off the request path — and, far more often, when it does not. */
+    ViableSkill["QueueDiscipline"] = "queue-discipline";
+    /** Writing a queue declaration, a job entrypoint and a processor that agree. */
+    ViableSkill["WorkerJobs"] = "worker-jobs";
+    /** Generating an @owlmeans/agent agent or pipeline INTO the application. */
+    ViableSkill["TargetAgents"] = "target-agents";
+    /** Whether a model call, a fixed pipeline or a tool-using agent is the right shape. */
+    ViableSkill["AgenticChoice"] = "agentic-choice";
+    /** Making a single model call from inside the generated application. */
+    ViableSkill["TargetLlm"] = "target-llm";
+    /** Giving the application's own agent its tools and its own installed skills. */
+    ViableSkill["TargetAgentTools"] = "target-agent-tools";
+    /** What a game brief is made of, and what it is not. */
+    ViableSkill["GameDesign"] = "game-design";
+    /** The three.js scene component — renderer, camera, loop, disposal. */
+    ViableSkill["GameScene"] = "game-scene";
+    /** Every control is an ordinary React component ABOVE the canvas, never inside it. */
+    ViableSkill["GameUi"] = "game-ui";
+    /** Casual, turn-based online and live online — and who owns the state in each. */
+    ViableSkill["GameNetworking"] = "game-networking";
+    ViableSkill["LayoutDefinition"] = "layout-definition";
+    ViableSkill["ScreenDefinition"] = "screen-definition";
+    ViableSkill["LibrariesCommon"] = "libraries-common";
+    ViableSkill["LibrariesUiState"] = "libraries-ui-state";
+    ViableSkill["LibrariesUi"] = "libraries-ui";
+    ViableSkill["LibrariesBackend"] = "libraries-backend";
+    ViableSkill["LibrariesAi"] = "libraries-ai";
+    ViableSkill["LibrariesGame"] = "libraries-game";
+})(ViableSkill || (ViableSkill = {}));
+/**
+ * Sort weights. Skills render in this order inside the cached block, so the sequence is
+ * part of the cache key — reordering them invalidates every prefix at once. Grouped in
+ * tens to leave room for a consumer's own skills between them.
+ */
+export const SKILL_ORDER = {
+    [ViableSkill.OutputSourceOnly]: 10,
+    [ViableSkill.OutputTextOnly]: 10,
+    [ViableSkill.ScopeDiscipline]: 15,
+    [ViableSkill.MainFlowFocus]: 12,
+    [ViableSkill.NonTypescriptOutput]: 18,
+    [ViableSkill.TsStyle]: 20,
+    [ViableSkill.TsImports]: 30,
+    [ViableSkill.ReactComponents]: 40,
+    [ViableSkill.OwlMeansEntrypoints]: 41,
+    [ViableSkill.OwlMeansNav]: 42,
+    [ViableSkill.PermissionModel]: 43,
+    [ViableSkill.ShadcnUi]: 44,
+    [ViableSkill.OwlmeansState]: 50,
+    [ViableSkill.FormFeedback]: 51,
+    [ViableSkill.StoreAccess]: 52,
+    [ViableSkill.ViewModelNaming]: 55,
+    [ViableSkill.ResourceLayer]: 60,
+    [ViableSkill.ResourceResults]: 62,
+    [ViableSkill.ResourceMigrations]: 64,
+    [ViableSkill.OwlMeansServer]: 70,
+    [ViableSkill.OwlmeansContext]: 65,
+    [ViableSkill.OwlMeansServices]: 66,
+    [ViableSkill.FixerHeuristics]: 75,
+    [ViableSkill.ProjectLayout]: 5,
+    [ViableSkill.AgentTooling]: 8,
+    [ViableSkill.QueueDiscipline]: 67,
+    [ViableSkill.WorkerJobs]: 68,
+    [ViableSkill.TargetAgents]: 69,
+    [ViableSkill.AgenticChoice]: 71,
+    [ViableSkill.TargetLlm]: 72,
+    [ViableSkill.TargetAgentTools]: 73,
+    [ViableSkill.GameDesign]: 45,
+    [ViableSkill.GameScene]: 46,
+    [ViableSkill.GameUi]: 47,
+    [ViableSkill.GameNetworking]: 48,
+    [ViableSkill.LayoutDefinition]: 80,
+    [ViableSkill.ScreenDefinition]: 82,
+    [ViableSkill.LibrariesCommon]: 90,
+    [ViableSkill.LibrariesUiState]: 90,
+    [ViableSkill.LibrariesUi]: 90,
+    [ViableSkill.LibrariesBackend]: 90,
+    [ViableSkill.LibrariesAi]: 90,
+    [ViableSkill.LibrariesGame]: 90,
+};
+/**
+ * The catalogue entries whose subject a PUBLISHED `@owlmeans` package already documents.
+ *
+ * The catalogue and `agent-meta/skills/*` state the same contract twice — the P1 duplication —
+ * and the duplication is not symmetric: a package skill is versioned with the package and reaches
+ * a prompt through `owlmeansPackagesPlugin` whenever the request names that package, while a
+ * catalogue entry is a constant here that has to be edited by hand every time the framework moves.
+ *
+ * Naming the overlap is what makes it a DATA decision instead of a code one. A blueprint lists
+ * which of these its prompts carry, and a persona's skills are filtered against that list — so
+ * dropping one is a line in a blueprint, and restoring it is the same line. Everything NOT in this
+ * set is viable's own (output discipline, scope, the view-model convention, the fixer heuristics,
+ * where files live) and always loads, because no published package documents it.
+ *
+ * The default blueprint currently lists every one of them: the reduction is a real change to what
+ * a coder is told, and it is measured against a green end-to-end baseline rather than guessed.
+ */
+export const FRAMEWORK_OWNED_SKILLS = [
+    ViableSkill.ResourceLayer,
+    ViableSkill.ResourceResults,
+    ViableSkill.ResourceMigrations,
+    ViableSkill.OwlmeansContext,
+    ViableSkill.OwlMeansServices,
+    ViableSkill.OwlMeansServer,
+    ViableSkill.OwlMeansEntrypoints,
+    ViableSkill.OwlMeansNav,
+    ViableSkill.PermissionModel,
+    ViableSkill.OwlmeansState,
+    ViableSkill.StoreAccess,
+    ViableSkill.ShadcnUi,
+    ViableSkill.ReactComponents,
+    ViableSkill.FormFeedback,
+];
+const FRAMEWORK_OWNED = new Set(FRAMEWORK_OWNED_SKILLS);
+/**
+ * Filter a persona's skills against what a blueprint asks for.
+ *
+ * A skill nobody owns always survives. A framework-owned one survives only while the blueprint
+ * lists it — so a blueprint built on another persistence layer stops teaching the Postgres
+ * resource contract without anybody editing a persona, and a blueprint that lists nothing at all
+ * (the shape a test builds) is read as "everything", because an empty allow-list almost always
+ * means "not stated" rather than "none".
+ */
+export const skillsForBlueprint = (skills, allowed) => {
+    if (allowed == null || allowed.length === 0)
+        return skills;
+    const permitted = new Set(allowed);
+    return skills.filter(skill => !FRAMEWORK_OWNED.has(skill) || permitted.has(skill));
+};
+//# sourceMappingURL=consts.js.map

package/build/skills/consts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"consts.js","sourceRoot":"","sources":["../../src/skills/consts.ts"],"names":[],"mappings":"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"}

package/build/skills/index.d.ts

@@ -0,0 +1,4 @@
+export * from './consts.js';
+export * from './catalogue.js';
+export * from './roles.js';
+//# sourceMappingURL=index.d.ts.map

package/build/skills/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/skills/index.ts"],"names":[],"mappings":"AACA,cAAc,aAAa,CAAA;AAC3B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,YAAY,CAAA"}

package/build/skills/index.js

@@ -0,0 +1,4 @@
+export * from './consts.js';
+export * from './catalogue.js';
+export * from './roles.js';
+//# sourceMappingURL=index.js.map

package/build/skills/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/skills/index.ts"],"names":[],"mappings":"AACA,cAAc,aAAa,CAAA;AAC3B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,YAAY,CAAA"}

package/build/skills/roles.d.ts

@@ -0,0 +1,52 @@
+import type { PromptPolicy } from '@owlmeans/llm-common';
+/**
+ * Who the model is being asked to be.
+ *
+ * A persona is per HELPER, not per model role: `ModelRole` selects which model answers,
+ * this selects what it is told it does. Two helpers can share a model and need different
+ * personas, and the same persona can run on a cheap or an expensive model depending on
+ * the effort tier — keeping the two axes separate is what makes that possible.
+ */
+export declare enum ViablePersona {
+    BusinessAnalyst = "business-analyst",
+    ProductNaming = "product-naming",
+    /** Decides what KIND of product a prompt describes — which blueprint case builds it. */
+    ProductArchitect = "product-architect",
+    UxDesigner = "ux-designer",
+    VisualDesigner = "visual-designer",
+    LayoutArchitect = "layout-architect",
+    ComponentArchitect = "component-architect",
+    StateArchitect = "state-architect",
+    NavigationArchitect = "navigation-architect",
+    DomainTypesArchitect = "domain-types-architect",
+    AccessArchitect = "access-architect",
+    ApiArchitect = "api-architect",
+    DatalayerArchitect = "datalayer-architect",
+    BackendDomainArchitect = "backend-domain-architect",
+    CommonCoder = "common-coder",
+    UiStateCoder = "ui-state-coder",
+    UiViewCoder = "ui-view-coder",
+    UiNavCoder = "ui-nav-coder",
+    DatalayerCoder = "datalayer-coder",
+    ApiCoder = "api-coder",
+    BackendModelCoder = "backend-model-coder",
+    /** Decides whether a story needs a queue, a worker or an agent — and usually decides it does not. */
+    RuntimeArchitect = "runtime-architect",
+    /** Writes queue declarations, job processors and the application's own agents. */
+    WorkerCoder = "worker-coder",
+    FreeFlightCoder = "free-flight-coder",
+    Fixer = "fixer",
+    Orchestrator = "orchestrator",
+    SourceExtractor = "source-extractor",
+    DeclarationLookup = "declaration-lookup",
+    FixAgent = "fix-agent"
+}
+/**
+ * The role text and skill set behind every helper.
+ *
+ * This is the single place a persona is written down. Before it existed the same
+ * sentences lived in thirteen helper files and seven near-identical coder factories, and
+ * the Express-5, resource-layer and client-state rules were duplicated across three of them.
+ */
+export declare const VIABLE_PERSONAS: Record<ViablePersona, PromptPolicy>;
+//# sourceMappingURL=roles.d.ts.map

package/build/skills/roles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roles.d.ts","sourceRoot":"","sources":["../../src/skills/roles.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AAGxD;;;;;;;GAOG;AACH,oBAAY,aAAa;IACvB,eAAe,qBAAqB;IACpC,aAAa,mBAAmB;IAChC,wFAAwF;IACxF,gBAAgB,sBAAsB;IACtC,UAAU,gBAAgB;IAC1B,cAAc,oBAAoB;IAElC,eAAe,qBAAqB;IACpC,kBAAkB,wBAAwB;IAC1C,cAAc,oBAAoB;IAClC,mBAAmB,yBAAyB;IAC5C,oBAAoB,2BAA2B;IAC/C,eAAe,qBAAqB;IACpC,YAAY,kBAAkB;IAC9B,kBAAkB,wBAAwB;IAC1C,sBAAsB,6BAA6B;IAEnD,WAAW,iBAAiB;IAC5B,YAAY,mBAAmB;IAC/B,WAAW,kBAAkB;IAC7B,UAAU,iBAAiB;IAC3B,cAAc,oBAAoB;IAClC,QAAQ,cAAc;IACtB,iBAAiB,wBAAwB;IACzC,qGAAqG;IACrG,gBAAgB,sBAAsB;IACtC,kFAAkF;IAClF,WAAW,iBAAiB;IAC5B,eAAe,sBAAsB;IAErC,KAAK,UAAU;IACf,YAAY,iBAAiB;IAC7B,eAAe,qBAAqB;IACpC,iBAAiB,uBAAuB;IACxC,QAAQ,cAAc;CACvB;AA6BD;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,aAAa,EAAE,YAAY,CAuN/D,CAAA"}

package/build/skills/roles.js

@@ -0,0 +1,256 @@
+import { ViableSkill } from './consts.js';
+/**
+ * Who the model is being asked to be.
+ *
+ * A persona is per HELPER, not per model role: `ModelRole` selects which model answers,
+ * this selects what it is told it does. Two helpers can share a model and need different
+ * personas, and the same persona can run on a cheap or an expensive model depending on
+ * the effort tier — keeping the two axes separate is what makes that possible.
+ */
+export var ViablePersona;
+(function (ViablePersona) {
+    ViablePersona["BusinessAnalyst"] = "business-analyst";
+    ViablePersona["ProductNaming"] = "product-naming";
+    /** Decides what KIND of product a prompt describes — which blueprint case builds it. */
+    ViablePersona["ProductArchitect"] = "product-architect";
+    ViablePersona["UxDesigner"] = "ux-designer";
+    ViablePersona["VisualDesigner"] = "visual-designer";
+    ViablePersona["LayoutArchitect"] = "layout-architect";
+    ViablePersona["ComponentArchitect"] = "component-architect";
+    ViablePersona["StateArchitect"] = "state-architect";
+    ViablePersona["NavigationArchitect"] = "navigation-architect";
+    ViablePersona["DomainTypesArchitect"] = "domain-types-architect";
+    ViablePersona["AccessArchitect"] = "access-architect";
+    ViablePersona["ApiArchitect"] = "api-architect";
+    ViablePersona["DatalayerArchitect"] = "datalayer-architect";
+    ViablePersona["BackendDomainArchitect"] = "backend-domain-architect";
+    ViablePersona["CommonCoder"] = "common-coder";
+    ViablePersona["UiStateCoder"] = "ui-state-coder";
+    ViablePersona["UiViewCoder"] = "ui-view-coder";
+    ViablePersona["UiNavCoder"] = "ui-nav-coder";
+    ViablePersona["DatalayerCoder"] = "datalayer-coder";
+    ViablePersona["ApiCoder"] = "api-coder";
+    ViablePersona["BackendModelCoder"] = "backend-model-coder";
+    /** Decides whether a story needs a queue, a worker or an agent — and usually decides it does not. */
+    ViablePersona["RuntimeArchitect"] = "runtime-architect";
+    /** Writes queue declarations, job processors and the application's own agents. */
+    ViablePersona["WorkerCoder"] = "worker-coder";
+    ViablePersona["FreeFlightCoder"] = "free-flight-coder";
+    ViablePersona["Fixer"] = "fixer";
+    ViablePersona["Orchestrator"] = "orchestrator";
+    ViablePersona["SourceExtractor"] = "source-extractor";
+    ViablePersona["DeclarationLookup"] = "declaration-lookup";
+    ViablePersona["FixAgent"] = "fix-agent";
+})(ViablePersona || (ViablePersona = {}));
+/** Shared by the two helpers that reason about domain models and shared types. */
+const DOMAIN_ARCHITECT = `
+You are a fullstack web developer architect specializing in state management, domain models,
+and typescript.
+`.trim();
+/** The rules every coder and the fixer need, whatever they are writing. */
+const CODING_BASE = [ViableSkill.OutputSourceOnly, ViableSkill.TsStyle, ViableSkill.TsImports];
+/** The frontend stack, in the order a component is built up. */
+const FRONTEND = [
+    ViableSkill.ReactComponents, ViableSkill.OwlMeansEntrypoints, ViableSkill.OwlMeansNav,
+    ViableSkill.OwlMeansServices, ViableSkill.ShadcnUi, ViableSkill.FormFeedback,
+    ViableSkill.StoreAccess, ViableSkill.ViewModelNaming, ViableSkill.LibrariesUi,
+];
+/** The backend stack. */
+const BACKEND = [
+    ViableSkill.ProjectLayout,
+    ViableSkill.ResourceLayer, ViableSkill.ResourceResults, ViableSkill.ResourceMigrations,
+    ViableSkill.OwlMeansEntrypoints, ViableSkill.OwlMeansServer, ViableSkill.OwlmeansContext,
+    ViableSkill.OwlMeansServices, ViableSkill.LibrariesBackend,
+];
+const persona = (role, skills) => ({ role: role.trim(), skills });
+/**
+ * The role text and skill set behind every helper.
+ *
+ * This is the single place a persona is written down. Before it existed the same
+ * sentences lived in thirteen helper files and seven near-identical coder factories, and
+ * the Express-5, resource-layer and client-state rules were duplicated across three of them.
+ */
+export const VIABLE_PERSONAS = {
+    // --- Analysis and design ---
+    [ViablePersona.BusinessAnalyst]: persona(`
+You are a professional business analyst and product manager specializing in figuring out
+user stories from requirements.
+`, [ViableSkill.OutputTextOnly, ViableSkill.MainFlowFocus]),
+    [ViablePersona.ProductArchitect]: persona(`
+You are a product architect. You read what somebody wants built and say which KIND of
+application it is, out of a fixed list. You choose the least capable kind that can deliver
+what was asked for, because every capability above it is machinery a real user pays for.
+You never stretch a description to fit a more interesting answer.
+`, [ViableSkill.OutputTextOnly]),
+    [ViablePersona.ProductNaming]: persona(`
+You are a professional product and brand manager specializing in naming.
+`, [ViableSkill.OutputTextOnly, ViableSkill.MainFlowFocus]),
+    [ViablePersona.UxDesigner]: persona(`
+You are a professional UX designer specializing in user flow and interaction in web
+applications.
+This application serves four audiences — anonymous visitors, signed-in end users, the owner,
+and staff running the business process. Every screen you design belongs to exactly one of them,
+and you are told which one with each task.
+`, [ViableSkill.OutputTextOnly]),
+    [ViablePersona.VisualDesigner]: persona(`
+You are a visual ui designer specializing in writing design guidelines and design systems
+for web applications that loves to produce expressive and bright interfaces.
+Unless a specification asks for something else, you default to a modern, expressive language —
+gradients, glass surfaces, layered shadows, restrained motion — while keeping every surface
+plainly readable. What makes a design yours is the values you choose, never the techniques you
+leave out.
+This application serves four audiences — anonymous visitors, signed-in end users, the owner,
+and staff running the business process. Every screen you style belongs to exactly one of them,
+and you are told which one with each task.
+`, [ViableSkill.OutputTextOnly]),
+    // --- Architects ---
+    [ViablePersona.LayoutArchitect]: persona(`
+You are a frontend developer architect working with typescript and react.
+You are specializing in screen layouts and their components.
+This application's layouts are the four AREA shells it already ships — guest, user, admin and
+operator — so you compose screens to sit inside one of them and you restyle a shell when it
+needs to look different. You never write a new layout and never rebuild its navigation.
+`, [ViableSkill.LayoutDefinition, ViableSkill.ScreenDefinition, ...FRONTEND]),
+    [ViablePersona.ComponentArchitect]: persona(`
+You are a frontend developer architect specializing in typescript react components.
+`, [...FRONTEND]),
+    [ViablePersona.StateArchitect]: persona(`
+You are a frontend developer architect specializing in state management and typescript.
+`, [ViableSkill.OwlmeansState, ViableSkill.StoreAccess, ViableSkill.ViewModelNaming,
+        ViableSkill.LibrariesUiState]),
+    [ViablePersona.NavigationArchitect]: persona(`
+You are a frontend developer architect working with typescript and react.
+You are specializing in UI navigation and transitioning.
+This application has four fixed AREAS — guest, user (front office), admin and operator (back
+office) — and two menu levels inside each: SECTIONS are the top menu, and the screens of the
+active section are the side menu. You place a screen by choosing its area and its section, never
+by editing a menu component and never by changing an address.
+`, [ViableSkill.OwlMeansEntrypoints, ViableSkill.OwlMeansNav, ViableSkill.ScreenDefinition,
+        ViableSkill.LibrariesUi]),
+    [ViablePersona.DomainTypesArchitect]: persona(DOMAIN_ARCHITECT, [ViableSkill.LibrariesCommon]),
+    // Not DOMAIN_ARCHITECT. This helper decides the application's entire authorization model — the
+    // least access each surface can be given, and one name per capability — and borrowing the
+    // state-management architect's sentence was describing a different job to the model.
+    [ViablePersona.AccessArchitect]: persona(`
+You are a web application security architect specializing in authorization.
+You decide the least access an endpoint or a screen can be given and still do its job, and you
+name permissions so that one capability has exactly one name across the whole application.
+`, [ViableSkill.OwlMeansEntrypoints, ViableSkill.PermissionModel, ViableSkill.LibrariesCommon]),
+    [ViablePersona.ApiArchitect]: persona(`
+You are an expert backend architect specializing in designing RESTful APIs using
+TypeScript and the OwlMeans entrypoint framework.
+`, [ViableSkill.OwlMeansEntrypoints, ViableSkill.OwlMeansServer, ViableSkill.ResourceLayer,
+        ViableSkill.ResourceResults, ViableSkill.OwlmeansContext, ViableSkill.LibrariesBackend]),
+    [ViablePersona.DatalayerArchitect]: persona(`
+You are a backend developer architect specializing in TypeScript, PostgreSQL and Node.js,
+working with the OwlMeans resource layer over Postgres (@owlmeans/postgres-resource), which
+owns the schema.
+`, [ViableSkill.ResourceLayer, ViableSkill.ResourceResults, ViableSkill.ResourceMigrations,
+        ViableSkill.OwlmeansContext, ViableSkill.LibrariesBackend]),
+    [ViablePersona.BackendDomainArchitect]: persona(`
+You are a backend developer architect specializing in business logic development.
+If necessary you describe which integrations to use.
+You prefer to use LLM chats models to solve sophisticated problems.
+You are always specific when consider some integrations.
+You always start from the business logic flow description that needs to be implemented
+and focus on it.
+`, [ViableSkill.ProjectLayout, ViableSkill.OwlmeansContext, ViableSkill.ResourceResults,
+        ViableSkill.LibrariesBackend]),
+    // --- Coders ---
+    // `PermissionModel` because this is the persona that WRITES the gate lines — `applyApiAccess`
+    // and `applyScreenAccess` both run on it. Knowing where the `@` may and may not appear has to
+    // reach the hand that types it, not only the one that chose the name.
+    [ViablePersona.CommonCoder]: persona(`
+You are an expert fullstack developer specializing in typescript and domain models.
+`, [...CODING_BASE, ViableSkill.OwlMeansEntrypoints, ViableSkill.PermissionModel,
+        ViableSkill.LibrariesCommon]),
+    [ViablePersona.UiStateCoder]: persona(`
+You are an expert frontend developer specializing in typescript and state management.
+`, [...CODING_BASE, ViableSkill.OwlmeansState, ViableSkill.OwlMeansEntrypoints,
+        ViableSkill.StoreAccess, ViableSkill.ViewModelNaming, ViableSkill.LibrariesUiState]),
+    [ViablePersona.UiViewCoder]: persona(`
+You are an expert frontend developer specializing in typescript, html, css, and react
+development of visual components.
+`, [...CODING_BASE, ...FRONTEND]),
+    [ViablePersona.UiNavCoder]: persona(`
+You are an expert frontend developer specializing in typescript, html, css, and react
+development of navigation and transitions.
+`, [...CODING_BASE, ...FRONTEND]),
+    [ViablePersona.DatalayerCoder]: persona(`
+You are an expert fullstack developer specializing in typescript, node.js and the OwlMeans
+resource layer over Postgres (@owlmeans/postgres-resource).
+`, [...CODING_BASE, ...BACKEND]),
+    [ViablePersona.ApiCoder]: persona(`
+You are an expert fullstack developer specializing in typescript, node.js, the OwlMeans
+entrypoint framework and its resource layer over Postgres (@owlmeans/postgres-resource).
+`, [...CODING_BASE, ...BACKEND]),
+    [ViablePersona.BackendModelCoder]: persona(`
+You are an expert backend developer specializing in typescript and node.js.
+You focus on business logic and integrations implementation — you really implement them,
+not just mock them.
+`, [...CODING_BASE, ViableSkill.ProjectLayout, ViableSkill.OwlmeansContext,
+        ViableSkill.ResourceResults, ViableSkill.LibrariesBackend]),
+    [ViablePersona.RuntimeArchitect]: persona(`
+You are a pragmatic backend architect. You decide what a feature needs to RUN, and your
+default answer is "a request handler and a table". You reach for a queue, a separate worker
+process or an LLM agent only when the work cannot honestly be done inside a request, and you
+say plainly which it is when the answer is none of them.
+`, [ViableSkill.QueueDiscipline, ViableSkill.ProjectLayout, ViableSkill.OwlmeansContext]),
+    [ViablePersona.WorkerCoder]: persona(`
+You are an expert backend developer specializing in typescript, queue processing and LLM
+agents. You write processors that are safe to run twice, because a worker can die mid-job.
+`, [...CODING_BASE, ViableSkill.ProjectLayout, ViableSkill.OwlmeansContext,
+        ViableSkill.WorkerJobs, ViableSkill.TargetAgents, ViableSkill.ResourceResults,
+        ViableSkill.LibrariesBackend]),
+    [ViablePersona.FreeFlightCoder]: persona(`
+You are an expert fullstack developer specializing in typescript.
+`, [...CODING_BASE, ...FRONTEND, ...BACKEND, ViableSkill.PermissionModel]),
+    // --- Everything else ---
+    [ViablePersona.Fixer]: persona(`
+You are an expert typescript fullstack developer specializing in bugfixing of web
+applications. You change as little as the reported error requires.
+`, [...CODING_BASE, ...FRONTEND, ...BACKEND, ViableSkill.FixerHeuristics,
+        ViableSkill.PermissionModel]),
+    // `OwlMeansEntrypoints` is what makes this persona able to ROUTE a report: the four contract
+    // files, and which of them a symptom belongs to. Without it a runtime `entrypoint.call is not a
+    // function` reads as a broken component, and the orchestrator sends a coder to rewrite the view
+    // model that is already correct.
+    //
+    // `OwlMeansServices` is here for the same reason one level down: this persona WRITES the
+    // instruction the coder follows, so it is the one that decides a `Service not found` is
+    // repaired by naming a different alias. It has to know which registry that name comes from
+    // before it delegates, or the coder inherits the wrong premise along with the task.
+    [ViablePersona.Orchestrator]: persona(`
+You are a senior fullstack typescript coding agent. You are orchestrating the
+development. Call the respective tools to inspect the project and to delegate the coding.
+`, [ViableSkill.ProjectLayout, ViableSkill.AgentTooling, ViableSkill.OwlmeansContext,
+        ViableSkill.OwlMeansEntrypoints, ViableSkill.OwlMeansServices, ViableSkill.PermissionModel,
+        ViableSkill.LayoutDefinition, ViableSkill.ScreenDefinition, ViableSkill.TsImports]),
+    [ViablePersona.SourceExtractor]: persona(`
+You are a code-context extraction agent. You are NOT writing code. Do not summarise.
+Your only deliverable is the tool call selecting the relevant line ranges. Be frugal —
+every extra line costs the coder context.
+`, []),
+    [ViablePersona.DeclarationLookup]: persona(`
+You are a TypeScript type-declaration lookup agent. You are NOT writing code and NOT
+fixing anything. Your only deliverable is the report_declarations tool call naming, for
+each requested type, the file that declares it. Be frugal — every tool call costs budget,
+and a wrong path is worse than an unresolved name.
+`, []),
+    [ViablePersona.FixAgent]: persona(`
+You are a build-repair agent working on a TypeScript monorepo you can inspect with tools.
+
+You are called only after a scripted fix loop has already failed on this error, so the
+obvious edit has been tried and did not work. Investigate before you edit: read the file
+the error points at, look up the authoritative name in the registry, search for the other
+places a name is spelled. A build error that keeps coming back is almost always a name
+that exists in two spellings or one that was never declared — declare or create the
+missing thing at its registered name; renaming a reference to a new guess is what made
+the loop circle.
+
+Make the smallest edit that addresses the cause, verify with the build, and finish with
+report_fix. Never delete a feature to silence an error, and never stub a handler to make
+the build pass.
+`, []),
+};
+//# sourceMappingURL=roles.js.map