crewly 1.13.0 → 1.13.1

package/dist/cli/backend/src/services/ai/prompt-modules/request-contract.module.js

@@ -0,0 +1,167 @@
+/**
+ * Request Contract block (P0-3).
+ *
+ * Per spec
+ * `.crewly/specs/2026-05-03-agent-improvement-p0-execution.md` §"Fix P0-3",
+ * this module emits a role-shaped Request Contract section. The contract
+ * defines the seven canonical fields a Request carries — Goal, Expected
+ * Outcome, Eval Criteria, Constraints, Decision Rights, Escalation
+ * Conditions, Done Definition — and pins **Goal + Expected Outcome + Eval
+ * Criteria** as the mandatory floor that every delegated subtask MUST carry.
+ *
+ * The module emits one of three role-shaped sections:
+ *
+ * 1. **Orchestrator** (orgRole === 'orchestrator' OR role === 'orchestrator'):
+ *    Full Request Contract field table + the rule that every delegated
+ *    subtask MUST carry G+O+E + the rejection rule TLs apply downstream.
+ *
+ * 2. **Team Lead** (orgRole === 'team-lead' OR canDelegate === true):
+ *    Brief Reception Protocol — receive task, verify G+O+E present, push
+ *    back to delegator if any are missing, propagate G+O+E verbatim when
+ *    sub-delegating to workers.
+ *
+ * 3. **Worker / executor** (everyone else):
+ *    Short G+O+E assertion — every task you accept should carry Goal,
+ *    Expected Outcome, and Eval Criteria; if any is missing, ask the
+ *    delegator (your TL or the orchestrator) before starting.
+ *
+ * Why a module (not just per-role markdown)?
+ * - Authority text must be identical across every agent of the same role.
+ *   A module guarantees byte-identical output instead of relying on N role
+ *   prompts staying in sync over time.
+ * - The text is small and authority-defining, so it cannot be truncated
+ *   under budget pressure → `compactable = false` (Trusted Zone).
+ * - Sits at priority 3.6 — immediately after DecisionRights (priority 3.5),
+ *   immediately before MemoryReference (priority 4). The contract belongs
+ *   in the authority cluster (Identity → Soul/Recovery → RoleBoundary →
+ *   DecisionRights → **RequestContract** → MemoryReference) so an agent
+ *   reads "what is a well-formed task" right after "who am I, what can I
+ *   decide".
+ *
+ * Static role prompts under `config/roles/orchestrator/prompt.md` and
+ * `config/roles/team-leader/{prompt.md,tl-addon.md}` ALSO contain the
+ * orchestrator + TL sections verbatim — this is intentional belt-and-
+ * suspenders coverage for the legacy `prompt-builder.service.ts` load path
+ * which does not run through `PromptAssemblyService`. The two paths
+ * produce different prompts for different runtimes; both must carry the
+ * contract.
+ *
+ * Net-zero offset: legacy "ask clarifying questions" / "if anything's
+ * unclear, ask" soft hints have been deleted from worker role prompts
+ * because this module + the structured G+O+E assertion supersede them.
+ */
+export class RequestContractModule {
+    name = 'request-contract';
+    priority = 3.6;
+    maxTokens = 600;
+    compactable = false;
+    /**
+     * Always include — every agent participates in the Request lifecycle:
+     * orchestrators issue contracts, TLs verify-and-propagate, workers
+     * consume. The block is small and the role-shape switch is internal.
+     *
+     * @param _config - Unused; the inclusion rule is universal
+     * @returns Always true
+     */
+    shouldInclude(_config) {
+        return true;
+    }
+    /**
+     * Build the role-shaped Request Contract section.
+     *
+     * Resolves the agent's role-shape via three stacked checks (in order):
+     *   1. `orgRole === 'orchestrator'` OR `role === 'orchestrator'` → orchestrator block
+     *   2. `orgRole === 'team-lead'` OR `canDelegate === true` → TL Brief Reception Protocol
+     *   3. anything else → Worker G+O+E assertion
+     *
+     * The role-shape inputs match the resolution order used by other
+     * authority modules (e.g. RoleBoundaryModule). Tests pin the matrix.
+     *
+     * @param config - Module configuration
+     * @returns Formatted markdown block with the role-shaped section
+     */
+    async build(config) {
+        const isOrchestrator = config.orgRole === 'orchestrator' || config.role === 'orchestrator';
+        if (isOrchestrator) {
+            return this.buildOrchestratorBlock();
+        }
+        const isTeamLead = config.orgRole === 'team-lead' || config.canDelegate === true;
+        if (isTeamLead) {
+            return this.buildTeamLeadBlock();
+        }
+        return this.buildWorkerBlock();
+    }
+    /**
+     * Build the orchestrator-side Request Contract.
+     *
+     * @returns Markdown block: `## Request Contract` with the seven-field
+     *   table, G+O+E mandatory rule, and downstream rejection clause.
+     */
+    buildOrchestratorBlock() {
+        return [
+            '## Request Contract',
+            '',
+            'When receiving a request from owner or upstream, every Request you materialise into the pipeline MUST carry these fields:',
+            '',
+            '| Field | Required | What it means |',
+            '|---|---|---|',
+            '| **Goal** | YES | What the user ultimately wants. |',
+            '| **Expected Outcome** | YES | What must be true when the work is done. |',
+            '| **Eval Criteria** | YES | Testable list — how we know this is good enough. |',
+            '| Constraints | If applicable | Time, tools, scope, risks, non-goals. |',
+            '| Decision Rights | If applicable | What the agent/team can decide autonomously. |',
+            '| Escalation Conditions | If applicable | What must be escalated before continuing. |',
+            '| **Done Definition** | YES | What artifact/result must be produced. |',
+            '',
+            '**Every delegated subtask MUST carry Goal + Expected Outcome + Eval Criteria at minimum.** A Team Lead is required to reject any subtask brief missing these three — that rejection comes back to you. If you find yourself dispatching work without G+O+E, stop and reconstruct the contract from the upstream Request before re-dispatching.',
+            '',
+            '### Conversation History — Recall Only',
+            '',
+            'Your conversation history is for **recall only**. Use it to remember context: who asked for what, what you discussed, what decisions you made.',
+            '',
+            'It is **not** the source of truth for what work is still in flight. Whether a task is unfinished — and whether to wake an agent — is decided by the pool: open Requests + queued/blocked WorkItems.',
+            '',
+            'If history makes you recall an unfinished thread but the pool has nothing on it, either the work is done (history is stale) or you must materialise it as a fresh Request before acting.',
+        ].join('\n');
+    }
+    /**
+     * Build the team-lead-side Brief Reception Protocol.
+     *
+     * @returns Markdown block: `## Brief Reception Protocol` with the
+     *   three-step verify / push-back / propagate-verbatim contract.
+     */
+    buildTeamLeadBlock() {
+        return [
+            '## Brief Reception Protocol',
+            '',
+            'When you receive a task brief from the orchestrator (or any upstream delegator):',
+            '',
+            '1. **Verify** that **Goal**, **Expected Outcome**, and **Eval Criteria** are present in the brief.',
+            '2. **Push back** if any of the three is missing — do not proceed, do not start decomposition, do not fan out work. Reply to the delegator naming the missing field(s) and request the contract be completed.',
+            '3. **Propagate verbatim** when sub-delegating to a worker — copy the Goal, Expected Outcome, and Eval Criteria from the parent brief into every child task. Workers should never have to ask you what success looks like.',
+            '',
+            'The Request Contract is the contract: G+O+E missing means the brief is malformed, regardless of how senior the delegator is.',
+        ].join('\n');
+    }
+    /**
+     * Build the worker-side G+O+E assertion.
+     *
+     * @returns Markdown block: `## Request Contract — What You Should See`
+     *   reminding workers to expect G+O+E in every task and to ask if any
+     *   is missing.
+     */
+    buildWorkerBlock() {
+        return [
+            '## Request Contract — What You Should See',
+            '',
+            'Every task you accept should arrive with three fields populated:',
+            '',
+            '- **Goal** — what the user ultimately wants.',
+            '- **Expected Outcome** — what must be true when the work is done.',
+            '- **Eval Criteria** — the testable list that decides whether the result is good enough.',
+            '',
+            'If any of the three is missing from a brief you receive, **ask the delegator (your Team Lead or the orchestrator) for it before starting**. Do not invent the contract yourself — that is how scope drifts. Asking for a missing field is not a clarifying question on facts; it is a contract repair.',
+        ].join('\n');
+    }
+}
+//# sourceMappingURL=request-contract.module.js.map

package/dist/cli/backend/src/services/ai/prompt-modules/request-contract.module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-contract.module.js","sourceRoot":"","sources":["../../../../../../../backend/src/services/ai/prompt-modules/request-contract.module.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,MAAM,OAAO,qBAAqB;IACjC,IAAI,GAAG,kBAAkB,CAAC;IAC1B,QAAQ,GAAG,GAAG,CAAC;IACf,SAAS,GAAG,GAAG,CAAC;IAChB,WAAW,GAAG,KAAK,CAAC;IAEpB;;;;;;;OAOG;IACH,aAAa,CAAC,OAAqB;QAClC,OAAO,IAAI,CAAC;IACb,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,KAAK,CAAC,KAAK,CAAC,MAAoB;QAC/B,MAAM,cAAc,GACnB,MAAM,CAAC,OAAO,KAAK,cAAc,IAAI,MAAM,CAAC,IAAI,KAAK,cAAc,CAAC;QACrE,IAAI,cAAc,EAAE,CAAC;YACpB,OAAO,IAAI,CAAC,sBAAsB,EAAE,CAAC;QACtC,CAAC;QAED,MAAM,UAAU,GACf,MAAM,CAAC,OAAO,KAAK,WAAW,IAAI,MAAM,CAAC,WAAW,KAAK,IAAI,CAAC;QAC/D,IAAI,UAAU,EAAE,CAAC;YAChB,OAAO,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAClC,CAAC;QAED,OAAO,IAAI,CAAC,gBAAgB,EAAE,CAAC;IAChC,CAAC;IAED;;;;;OAKG;IACK,sBAAsB;QAC7B,OAAO;YACN,qBAAqB;YACrB,EAAE;YACF,2HAA2H;YAC3H,EAAE;YACF,sCAAsC;YACtC,eAAe;YACf,sDAAsD;YACtD,2EAA2E;YAC3E,gFAAgF;YAChF,yEAAyE;YACzE,oFAAoF;YACpF,uFAAuF;YACvF,wEAAwE;YACxE,EAAE;YACF,gVAAgV;YAChV,EAAE;YACF,wCAAwC;YACxC,EAAE;YACF,gJAAgJ;YAChJ,EAAE;YACF,qMAAqM;YACrM,EAAE;YACF,0LAA0L;SAC1L,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACd,CAAC;IAED;;;;;OAKG;IACK,kBAAkB;QACzB,OAAO;YACN,6BAA6B;YAC7B,EAAE;YACF,kFAAkF;YAClF,EAAE;YACF,oGAAoG;YACpG,8MAA8M;YAC9M,2NAA2N;YAC3N,EAAE;YACF,8HAA8H;SAC9H,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACd,CAAC;IAED;;;;;;OAMG;IACK,gBAAgB;QACvB,OAAO;YACN,2CAA2C;YAC3C,EAAE;YACF,kEAAkE;YAClE,EAAE;YACF,8CAA8C;YAC9C,mEAAmE;YACnE,yFAAyF;YACzF,EAAE;YACF,wSAAwS;SACxS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACd,CAAC;CACD"}

package/dist/cli/backend/src/services/ai/prompt-modules/risk-policy.module.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Risk Policy module — loads risk-specific policy documents.
+ *
+ * Reads a markdown policy file from config/risk-policies/{riskPolicy}.policy.md
+ * and injects it into the agent prompt as a constraint layer.
+ * V1 scope: constraint and procedure layer only.
+ *
+ * Delegates to buildMarkdownFileModule for the shared read-file-and-format logic.
+ */
+import type { PromptModule, ModuleConfig } from './prompt-module.interface.js';
+/**
+ * Prompt module that loads risk-specific policies from disk.
+ * Instantiable class wrapper around the shared markdown-file helper.
+ */
+export declare class RiskPolicyModule implements PromptModule {
+    name: string;
+    priority: number;
+    maxTokens: number;
+    compactable: boolean;
+    /**
+     * Include this module only when a riskPolicy name is configured.
+     *
+     * @param config - Module configuration with optional riskPolicy field
+     * @returns True if riskPolicy is set, false otherwise
+     */
+    shouldInclude(config: ModuleConfig): boolean;
+    /**
+     * Build the risk policy section by loading the corresponding markdown file.
+     *
+     * @param config - Module configuration containing riskPolicy name and projectRoot
+     * @returns Formatted markdown section with policy content or fallback message
+     */
+    build(config: ModuleConfig): Promise<string>;
+}
+//# sourceMappingURL=risk-policy.module.d.ts.map

package/dist/cli/backend/src/services/ai/prompt-modules/risk-policy.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"risk-policy.module.d.ts","sourceRoot":"","sources":["../../../../../../../backend/src/services/ai/prompt-modules/risk-policy.module.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAc/E;;;GAGG;AACH,qBAAa,gBAAiB,YAAW,YAAY;IACpD,IAAI,SAAiB;IACrB,QAAQ,SAAqB;IAC7B,SAAS,SAAsB;IAC/B,WAAW,UAAwB;IAEnC;;;;;OAKG;IACH,aAAa,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO;IAI5C;;;;;OAKG;IACG,KAAK,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC;CAGlD"}

package/dist/cli/backend/src/services/ai/prompt-modules/risk-policy.module.js

@@ -0,0 +1,50 @@
+/**
+ * Risk Policy module — loads risk-specific policy documents.
+ *
+ * Reads a markdown policy file from config/risk-policies/{riskPolicy}.policy.md
+ * and injects it into the agent prompt as a constraint layer.
+ * V1 scope: constraint and procedure layer only.
+ *
+ * Delegates to buildMarkdownFileModule for the shared read-file-and-format logic.
+ */
+import { buildMarkdownFileModule } from './markdown-file-module.js';
+const delegate = buildMarkdownFileModule({
+    name: 'risk-policy',
+    priority: 10,
+    maxTokens: 800,
+    compactable: true,
+    configSubDir: 'risk-policies',
+    fileExtension: '.policy.md',
+    headingLabel: 'Risk Policy',
+    missingFileHint: 'Policy file not found at',
+    getConfigValue: (config) => config.riskPolicy,
+});
+/**
+ * Prompt module that loads risk-specific policies from disk.
+ * Instantiable class wrapper around the shared markdown-file helper.
+ */
+export class RiskPolicyModule {
+    name = delegate.name;
+    priority = delegate.priority;
+    maxTokens = delegate.maxTokens;
+    compactable = delegate.compactable;
+    /**
+     * Include this module only when a riskPolicy name is configured.
+     *
+     * @param config - Module configuration with optional riskPolicy field
+     * @returns True if riskPolicy is set, false otherwise
+     */
+    shouldInclude(config) {
+        return delegate.shouldInclude(config);
+    }
+    /**
+     * Build the risk policy section by loading the corresponding markdown file.
+     *
+     * @param config - Module configuration containing riskPolicy name and projectRoot
+     * @returns Formatted markdown section with policy content or fallback message
+     */
+    async build(config) {
+        return delegate.build(config);
+    }
+}
+//# sourceMappingURL=risk-policy.module.js.map

package/dist/cli/backend/src/services/ai/prompt-modules/risk-policy.module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"risk-policy.module.js","sourceRoot":"","sources":["../../../../../../../backend/src/services/ai/prompt-modules/risk-policy.module.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AAGpE,MAAM,QAAQ,GAAG,uBAAuB,CAAC;IACxC,IAAI,EAAE,aAAa;IACnB,QAAQ,EAAE,EAAE;IACZ,SAAS,EAAE,GAAG;IACd,WAAW,EAAE,IAAI;IACjB,YAAY,EAAE,eAAe;IAC7B,aAAa,EAAE,YAAY;IAC3B,YAAY,EAAE,aAAa;IAC3B,eAAe,EAAE,0BAA0B;IAC3C,cAAc,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,UAAU;CAC7C,CAAC,CAAC;AAEH;;;GAGG;AACH,MAAM,OAAO,gBAAgB;IAC5B,IAAI,GAAG,QAAQ,CAAC,IAAI,CAAC;IACrB,QAAQ,GAAG,QAAQ,CAAC,QAAQ,CAAC;IAC7B,SAAS,GAAG,QAAQ,CAAC,SAAS,CAAC;IAC/B,WAAW,GAAG,QAAQ,CAAC,WAAW,CAAC;IAEnC;;;;;OAKG;IACH,aAAa,CAAC,MAAoB;QACjC,OAAO,QAAQ,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;IACvC,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,KAAK,CAAC,MAAoB;QAC/B,OAAO,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IAC/B,CAAC;CACD"}

package/dist/cli/backend/src/services/ai/prompt-modules/role-boundary.module.d.ts

@@ -0,0 +1,91 @@
+import { PromptModule, ModuleConfig } from './prompt-module.interface.js';
+/**
+ * Role Boundary module — enforces per-role boundaries and the Try-Before-Refuse protocol.
+ *
+ * Generates role-specific boundary rules based on the agent's organizational role
+ * (orchestrator, team-lead, or executor). Boundaries define what the agent IS and
+ * IS NOT responsible for, plus the mandatory Try-Before-Refuse protocol that prevents
+ * premature task refusal.
+ *
+ * This module is non-compactable (never trimmed) because boundary violations
+ * cause cascading workflow failures.
+ *
+ * Priority 3 ensures boundaries are injected early, right after identity and soul.
+ */
+export declare class RoleBoundaryModule implements PromptModule {
+    name: string;
+    priority: number;
+    maxTokens: number;
+    compactable: boolean;
+    /**
+     * Always included — every agent needs role boundaries.
+     *
+     * @param _config - Module configuration (unused)
+     * @returns Always true
+     */
+    shouldInclude(_config: ModuleConfig): boolean;
+    /**
+     * Build the role boundary section based on the agent's organizational role.
+     *
+     * First attempts to load a custom role-boundary fragment from
+     * config/roles/{role}/fragments/role-boundary.md. If not found,
+     * falls back to inline content determined by orgRole.
+     *
+     * @param config - Module configuration with orgRole and role fields
+     * @returns Formatted markdown role boundary section
+     */
+    build(config: ModuleConfig): Promise<string>;
+    /**
+     * Build organization context section (job, ownership, service contract).
+     * Appended to every role boundary to inject team-given responsibilities.
+     */
+    private buildOrganizationContext;
+    /**
+     * Build the shared Guidance Priority Chain that applies to all roles.
+     *
+     * Defines the explicit conflict resolution order when multiple sources
+     * of guidance (role, SOP, norm, memory) disagree. Higher-priority
+     * constraints always win.
+     *
+     * @returns Guidance priority chain markdown
+     */
+    private buildGuidancePriorityChain;
+    /**
+     * Build the shared Core Execution Principles that apply to all roles.
+     *
+     * These three principles unify alignment and decomposition behavior
+     * across the entire agent hierarchy.
+     *
+     * @returns Core execution principles markdown
+     */
+    private buildCoreExecutionPrinciples;
+    /**
+     * Build boundary content for the orchestrator role.
+     *
+     * Orchestrators are message routers and context compressors.
+     * They must not make strategy decisions or write code.
+     *
+     * @returns Orchestrator boundary markdown
+     */
+    private buildOrchestratorBoundary;
+    /**
+     * Build boundary content for the team-lead role.
+     *
+     * Team leads own objectives, decompose tasks, delegate to subordinates,
+     * and verify quality. They do not communicate directly with users.
+     *
+     * @returns Team lead boundary markdown
+     */
+    private buildTeamLeadBoundary;
+    /**
+     * Build boundary content for the executor role.
+     *
+     * Executors are scoped implementers who must attempt work before
+     * reporting blocked. They classify tasks before executing, provide
+     * structured block reports, and never self-verify as complete.
+     *
+     * @returns Executor boundary markdown
+     */
+    private buildExecutorBoundary;
+}
+//# sourceMappingURL=role-boundary.module.d.ts.map

package/dist/cli/backend/src/services/ai/prompt-modules/role-boundary.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"role-boundary.module.d.ts","sourceRoot":"","sources":["../../../../../../../backend/src/services/ai/prompt-modules/role-boundary.module.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,YAAY,EAAoB,MAAM,8BAA8B,CAAC;AAgB5F;;;;;;;;;;;;GAYG;AACH,qBAAa,kBAAmB,YAAW,YAAY;IACtD,IAAI,SAAmB;IACvB,QAAQ,SAAK;IACb,SAAS,SAAQ;IACjB,WAAW,UAAS;IAEpB;;;;;OAKG;IACH,aAAa,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO;IAI7C;;;;;;;;;OASG;IACG,KAAK,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC;IA4ElD;;;OAGG;IACH,OAAO,CAAC,wBAAwB;IA2ChC;;;;;;;;OAQG;IACH,OAAO,CAAC,0BAA0B;IAoBlC;;;;;;;OAOG;IACH,OAAO,CAAC,4BAA4B;IAUpC;;;;;;;OAOG;IACH,OAAO,CAAC,yBAAyB;IA8CjC;;;;;;;OAOG;IACH,OAAO,CAAC,qBAAqB;IA2D7B;;;;;;;;OAQG;IACH,OAAO,CAAC,qBAAqB;CA8E7B"}