sylas-edge-worker 0.2.21

package/dist/procedures/registry.js

@@ -0,0 +1,240 @@
+/**
+ * Registry of predefined procedures and analysis rules
+ */
+/**
+ * Predefined subroutine definitions
+ */
+export const SUBROUTINES = {
+    primary: {
+        name: "primary",
+        promptPath: "primary", // Special: resolved via label (debugger/builder/scoper/orchestrator) or direct user input
+        description: "Main work execution phase",
+    },
+    debuggerReproduction: {
+        name: "debugger-reproduction",
+        promptPath: "subroutines/debugger-reproduction.md",
+        description: "Reproduce bug and perform root cause analysis",
+    },
+    getApproval: {
+        name: "get-approval",
+        promptPath: "subroutines/get-approval.md",
+        description: "Request user approval before proceeding",
+        singleTurn: true,
+        requiresApproval: true, // Flag to trigger approval workflow
+    },
+    debuggerFix: {
+        name: "debugger-fix",
+        promptPath: "subroutines/debugger-fix.md",
+        description: "Implement minimal fix based on approved reproduction",
+    },
+    verifications: {
+        name: "verifications",
+        promptPath: "subroutines/verifications.md",
+        description: "Run tests, linting, and type checking",
+        usesValidationLoop: true, // Enable validation loop with retry logic
+    },
+    validationFixer: {
+        name: "validation-fixer",
+        promptPath: "subroutines/validation-fixer.md",
+        description: "Fix validation failures from the verifications subroutine",
+    },
+    gitCommit: {
+        name: "git-commit",
+        promptPath: "subroutines/git-commit.md",
+        description: "Stage, commit, and push changes to remote",
+    },
+    ghPr: {
+        name: "gh-pr",
+        promptPath: "subroutines/gh-pr.md",
+        description: "Create or update GitHub Pull Request",
+    },
+    changelogUpdate: {
+        name: "changelog-update",
+        promptPath: "subroutines/changelog-update.md",
+        description: "Update changelog (only if changelog files exist)",
+    },
+    conciseSummary: {
+        name: "concise-summary",
+        promptPath: "subroutines/concise-summary.md",
+        singleTurn: true,
+        description: "Brief summary for simple requests",
+        suppressThoughtPosting: true,
+        disallowAllTools: true,
+    },
+    verboseSummary: {
+        name: "verbose-summary",
+        promptPath: "subroutines/verbose-summary.md",
+        singleTurn: true,
+        description: "Detailed summary with implementation details",
+        suppressThoughtPosting: true,
+        disallowAllTools: true,
+    },
+    questionInvestigation: {
+        name: "question-investigation",
+        promptPath: "subroutines/question-investigation.md",
+        description: "Gather information needed to answer a question",
+    },
+    questionAnswer: {
+        name: "question-answer",
+        promptPath: "subroutines/question-answer.md",
+        singleTurn: true,
+        description: "Format final answer to user question",
+        suppressThoughtPosting: true,
+        disallowAllTools: true,
+    },
+    codingActivity: {
+        name: "coding-activity",
+        promptPath: "subroutines/coding-activity.md",
+        description: "Implementation phase for code changes (no git/gh operations)",
+    },
+    preparation: {
+        name: "preparation",
+        promptPath: "subroutines/preparation.md",
+        description: "Analyze request to determine if clarification or planning is needed",
+    },
+    planSummary: {
+        name: "plan-summary",
+        promptPath: "subroutines/plan-summary.md",
+        singleTurn: true,
+        description: "Present clarifying questions or implementation plan",
+        suppressThoughtPosting: true,
+        disallowAllTools: true,
+    },
+    userTesting: {
+        name: "user-testing",
+        promptPath: "subroutines/user-testing.md",
+        description: "Perform testing as requested by the user",
+    },
+    userTestingSummary: {
+        name: "user-testing-summary",
+        promptPath: "subroutines/user-testing-summary.md",
+        singleTurn: true,
+        description: "Summary of user testing session results",
+        suppressThoughtPosting: true,
+        disallowAllTools: true,
+    },
+    releaseExecution: {
+        name: "release-execution",
+        promptPath: "subroutines/release-execution.md",
+        description: "Execute release process using project skill or gather release info via AskUserQuestion",
+    },
+    releaseSummary: {
+        name: "release-summary",
+        promptPath: "subroutines/release-summary.md",
+        singleTurn: true,
+        description: "Summary of the release process",
+        suppressThoughtPosting: true,
+        disallowAllTools: true,
+    },
+    fullDelegation: {
+        name: "full-delegation",
+        promptPath: "subroutines/full-delegation.md",
+        description: "Full delegation to a smart runner — coding, testing, committing, PR creation, and summary in a single session",
+    },
+};
+/**
+ * Predefined procedure definitions
+ */
+export const PROCEDURES = {
+    "simple-question": {
+        name: "simple-question",
+        description: "For questions or requests that don't modify the codebase",
+        subroutines: [
+            SUBROUTINES.questionInvestigation,
+            SUBROUTINES.questionAnswer,
+        ],
+    },
+    "documentation-edit": {
+        name: "documentation-edit",
+        description: "For documentation/markdown edits that don't require verification",
+        subroutines: [
+            SUBROUTINES.primary,
+            SUBROUTINES.gitCommit,
+            SUBROUTINES.ghPr,
+            SUBROUTINES.conciseSummary,
+        ],
+    },
+    "full-development": {
+        name: "full-development",
+        description: "For code changes requiring full verification and PR creation",
+        subroutines: [
+            SUBROUTINES.codingActivity,
+            SUBROUTINES.verifications,
+            SUBROUTINES.changelogUpdate,
+            SUBROUTINES.gitCommit,
+            SUBROUTINES.ghPr,
+            SUBROUTINES.conciseSummary,
+        ],
+    },
+    "debugger-full": {
+        name: "debugger-full",
+        description: "Full debugging workflow with reproduction, fix, and verification",
+        subroutines: [
+            SUBROUTINES.debuggerReproduction,
+            SUBROUTINES.debuggerFix,
+            SUBROUTINES.verifications,
+            SUBROUTINES.changelogUpdate,
+            SUBROUTINES.gitCommit,
+            SUBROUTINES.ghPr,
+            SUBROUTINES.conciseSummary,
+        ],
+    },
+    "orchestrator-full": {
+        name: "orchestrator-full",
+        description: "Full orchestration workflow with decomposition and delegation to sub-agents",
+        subroutines: [SUBROUTINES.primary, SUBROUTINES.conciseSummary],
+    },
+    "plan-mode": {
+        name: "plan-mode",
+        description: "Planning mode for requests needing clarification or implementation planning",
+        subroutines: [SUBROUTINES.preparation, SUBROUTINES.planSummary],
+    },
+    "user-testing": {
+        name: "user-testing",
+        description: "User-driven testing workflow for manual testing sessions",
+        subroutines: [SUBROUTINES.userTesting, SUBROUTINES.userTestingSummary],
+    },
+    release: {
+        name: "release",
+        description: "Release workflow that invokes project release skill or asks user for release info",
+        subroutines: [SUBROUTINES.releaseExecution, SUBROUTINES.releaseSummary],
+    },
+    "full-delegation": {
+        name: "full-delegation",
+        description: "Single-session full delegation for smart runners (OpenCode + oh-my-opencode) — the runner handles the entire workflow autonomously",
+        subroutines: [SUBROUTINES.fullDelegation],
+    },
+};
+/**
+ * Mapping from request classification to procedure name
+ */
+export const CLASSIFICATION_TO_PROCEDURE = {
+    question: "simple-question",
+    documentation: "documentation-edit",
+    transient: "simple-question",
+    planning: "plan-mode",
+    code: "full-development",
+    debugger: "debugger-full",
+    orchestrator: "orchestrator-full",
+    "user-testing": "user-testing",
+    release: "release",
+};
+/**
+ * Get a procedure definition by name
+ */
+export function getProcedure(name) {
+    return PROCEDURES[name];
+}
+/**
+ * Get procedure name for a given classification
+ */
+export function getProcedureForClassification(classification) {
+    return CLASSIFICATION_TO_PROCEDURE[classification];
+}
+/**
+ * Get all available procedure names
+ */
+export function getAllProcedureNames() {
+    return Object.keys(PROCEDURES);
+}
+//# sourceMappingURL=registry.js.map

package/dist/procedures/registry.js.map

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

package/dist/procedures/types.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Type definitions for the procedure analysis system
+ */
+/**
+ * Definition of a single subroutine in a procedure
+ */
+export interface SubroutineDefinition {
+    /** Unique identifier for the subroutine */
+    name: string;
+    /** Path to the prompt file (relative to edge-worker/src/prompts/) */
+    promptPath: string;
+    /** Whether this subroutine should run in single-turn mode (maxTurns: 1) */
+    singleTurn?: boolean;
+    /** Human-readable description of what this subroutine does */
+    description: string;
+    /** Whether this subroutine should skip posting to Linear activity stream */
+    skipLinearPost?: boolean;
+    /** Whether to suppress posting thoughts/actions (still posts final summary) */
+    suppressThoughtPosting?: boolean;
+    /** Whether this subroutine requires user approval before advancing to next step */
+    requiresApproval?: boolean;
+    /** Tools that should be explicitly disallowed during this subroutine */
+    disallowedTools?: readonly string[];
+    /**
+     * Whether to disallow ALL tool usage during this subroutine.
+     * When true, the agent will only produce text output without any tool calls.
+     * This is useful for summary subroutines where tool usage would cause
+     * the session to appear "hanging" to users in Linear.
+     */
+    disallowAllTools?: boolean;
+    /**
+     * Whether this subroutine uses the validation loop with retry logic.
+     * When true, the subroutine output is parsed as ValidationResult and
+     * the validation-fixer subroutine is run on failures (up to maxIterations).
+     */
+    usesValidationLoop?: boolean;
+}
+/**
+ * Complete definition of a procedure (sequence of subroutines)
+ */
+export interface ProcedureDefinition {
+    /** Unique identifier for the procedure */
+    name: string;
+    /** Human-readable description of when to use this procedure */
+    description: string;
+    /** Ordered list of subroutines to execute */
+    subroutines: SubroutineDefinition[];
+}
+/**
+ * Validation loop state for subroutines that use retry logic
+ */
+export interface ValidationLoopMetadata {
+    /** Current iteration (1-based) */
+    iteration: number;
+    /** Whether the loop is in fixer mode (running validation-fixer) */
+    inFixerMode: boolean;
+    /** Results from each validation attempt */
+    attempts: Array<{
+        iteration: number;
+        pass: boolean;
+        reason: string;
+        timestamp: number;
+    }>;
+}
+/**
+ * Procedure metadata stored in session.metadata.procedure
+ */
+export interface ProcedureMetadata {
+    /** Name of the active procedure */
+    procedureName: string;
+    /** Current position in the subroutine sequence (0-indexed) */
+    currentSubroutineIndex: number;
+    /** History of completed subroutines */
+    subroutineHistory: Array<{
+        subroutine: string;
+        completedAt: number;
+        claudeSessionId: string | null;
+        geminiSessionId: string | null;
+        codexSessionId?: string | null;
+        cursorSessionId?: string | null;
+        openCodeSessionId?: string | null;
+        /** The result text from the completed subroutine (if available) */
+        result?: string;
+    }>;
+    /** State for validation loop (when current subroutine uses usesValidationLoop) */
+    validationLoop?: ValidationLoopMetadata;
+}
+/**
+ * Request classification types for analysis decisions
+ */
+export type RequestClassification = "question" | "documentation" | "transient" | "planning" | "code" | "debugger" | "orchestrator" | "user-testing" | "release";
+/**
+ * Result of procedure analysis decision
+ */
+export interface ProcedureAnalysisDecision {
+    /** Classification of the request */
+    classification: RequestClassification;
+    /** Selected procedure to execute */
+    procedure: ProcedureDefinition;
+    /** Reasoning for the classification (for debugging) */
+    reasoning?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/procedures/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/procedures/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACpC,2CAA2C;IAC3C,IAAI,EAAE,MAAM,CAAC;IAEb,qEAAqE;IACrE,UAAU,EAAE,MAAM,CAAC;IAEnB,2EAA2E;IAC3E,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB,8DAA8D;IAC9D,WAAW,EAAE,MAAM,CAAC;IAEpB,4EAA4E;IAC5E,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB,+EAA+E;IAC/E,sBAAsB,CAAC,EAAE,OAAO,CAAC;IAEjC,mFAAmF;IACnF,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAE3B,wEAAwE;IACxE,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAEpC;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAE3B;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IACnC,0CAA0C;IAC1C,IAAI,EAAE,MAAM,CAAC;IAEb,+DAA+D;IAC/D,WAAW,EAAE,MAAM,CAAC;IAEpB,6CAA6C;IAC7C,WAAW,EAAE,oBAAoB,EAAE,CAAC;CACpC;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACtC,kCAAkC;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,mEAAmE;IACnE,WAAW,EAAE,OAAO,CAAC;IACrB,2CAA2C;IAC3C,QAAQ,EAAE,KAAK,CAAC;QACf,SAAS,EAAE,MAAM,CAAC;QAClB,IAAI,EAAE,OAAO,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;QACf,SAAS,EAAE,MAAM,CAAC;KAClB,CAAC,CAAC;CACH;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IACjC,mCAAmC;IACnC,aAAa,EAAE,MAAM,CAAC;IAEtB,8DAA8D;IAC9D,sBAAsB,EAAE,MAAM,CAAC;IAE/B,uCAAuC;IACvC,iBAAiB,EAAE,KAAK,CAAC;QACxB,UAAU,EAAE,MAAM,CAAC;QACnB,WAAW,EAAE,MAAM,CAAC;QACpB,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;QAC/B,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;QAC/B,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAC/B,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAChC,iBAAiB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAClC,mEAAmE;QACnE,MAAM,CAAC,EAAE,MAAM,CAAC;KAChB,CAAC,CAAC;IAEH,kFAAkF;IAClF,cAAc,CAAC,EAAE,sBAAsB,CAAC;CACxC;AAED;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAC9B,UAAU,GACV,eAAe,GACf,WAAW,GACX,UAAU,GACV,MAAM,GACN,UAAU,GACV,cAAc,GACd,cAAc,GACd,SAAS,CAAC;AAEb;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACzC,oCAAoC;IACpC,cAAc,EAAE,qBAAqB,CAAC;IAEtC,oCAAoC;IACpC,SAAS,EAAE,mBAAmB,CAAC;IAE/B,uDAAuD;IACvD,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB"}

package/dist/procedures/types.js

@@ -0,0 +1,5 @@
+/**
+ * Type definitions for the procedure analysis system
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/procedures/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/procedures/types.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/prompt-assembly/types.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Type definitions for the unified prompt assembly system
+ *
+ * This module provides a clear, testable interface for assembling prompts
+ * with well-defined inputs and outputs.
+ */
+import type { GuidanceRule, Issue, RepositoryConfig, SylasAgentSession, WebhookAgentSession } from "sylas-core";
+/**
+ * Output structure from buildPrompt - contains everything needed to start a Claude session
+ */
+export interface PromptAssembly {
+    /** System prompt for Claude runner configuration (e.g., "builder", "debugger") */
+    systemPrompt?: string;
+    /** The complete user prompt to send to Claude */
+    userPrompt: string;
+    /** Metadata about what was assembled (for debugging and testing) */
+    metadata: {
+        /** List of components included in the prompt */
+        components: PromptComponent[];
+        /** Name of the subroutine prompt loaded (if any) */
+        subroutineName?: string;
+        /** Type of prompt builder used */
+        promptType: PromptType;
+        /** Whether this was a new session */
+        isNewSession: boolean;
+        /** Whether the session is actively streaming */
+        isStreaming: boolean;
+    };
+}
+/**
+ * Components that can be included in a prompt
+ */
+export type PromptComponent = "issue-context" | "subroutine-prompt" | "user-comment" | "attachment-manifest" | "guidance-rules";
+/**
+ * Type of prompt builder used
+ */
+export type PromptType = "label-based" | "label-based-prompt-command" | "mention" | "fallback" | "continuation";
+/**
+ * Input structure for buildPrompt - all information needed to assemble a prompt
+ */
+export interface PromptAssemblyInput {
+    /** The Sylas agent session */
+    session: SylasAgentSession;
+    /** Full issue details */
+    fullIssue: Issue;
+    /** Repository configuration */
+    repository: RepositoryConfig;
+    /** User's comment text (or empty string for initial assignment) */
+    userComment: string;
+    /** Author of the comment (for multi-player context) */
+    commentAuthor?: string;
+    /** Timestamp of the comment (for multi-player context) */
+    commentTimestamp?: string;
+    /** Attachment manifest string (if any attachments) */
+    attachmentManifest?: string;
+    /** Linear agent guidance rules */
+    guidance?: GuidanceRule[];
+    /** Whether this is a new session (vs continuation) */
+    isNewSession: boolean;
+    /** Whether the Claude runner is actively streaming */
+    isStreaming: boolean;
+    /** Whether triggered by @mention */
+    isMentionTriggered?: boolean;
+    /** Whether /label-based-prompt command was used */
+    isLabelBasedPromptRequested?: boolean;
+    /** Agent session data (for mention-triggered prompts) */
+    agentSession?: WebhookAgentSession;
+    /** Labels on the issue (for system prompt determination) */
+    labels?: string[];
+}
+/**
+ * Result from building issue context (intermediate step)
+ */
+export interface IssueContextResult {
+    /** The assembled issue context prompt */
+    prompt: string;
+    /** Template version (if using versioned templates) */
+    version?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/prompt-assembly/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/prompt-assembly/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACX,YAAY,EACZ,KAAK,EACL,gBAAgB,EAChB,iBAAiB,EACjB,mBAAmB,EACnB,MAAM,YAAY,CAAC;AAEpB;;GAEG;AACH,MAAM,WAAW,cAAc;IAC9B,kFAAkF;IAClF,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB,iDAAiD;IACjD,UAAU,EAAE,MAAM,CAAC;IAEnB,oEAAoE;IACpE,QAAQ,EAAE;QACT,gDAAgD;QAChD,UAAU,EAAE,eAAe,EAAE,CAAC;QAE9B,oDAAoD;QACpD,cAAc,CAAC,EAAE,MAAM,CAAC;QAExB,kCAAkC;QAClC,UAAU,EAAE,UAAU,CAAC;QAEvB,qCAAqC;QACrC,YAAY,EAAE,OAAO,CAAC;QAEtB,gDAAgD;QAChD,WAAW,EAAE,OAAO,CAAC;KACrB,CAAC;CACF;AAED;;GAEG;AACH,MAAM,MAAM,eAAe,GACxB,eAAe,GACf,mBAAmB,GACnB,cAAc,GACd,qBAAqB,GACrB,gBAAgB,CAAC;AAEpB;;GAEG;AACH,MAAM,MAAM,UAAU,GACnB,aAAa,GACb,4BAA4B,GAC5B,SAAS,GACT,UAAU,GACV,cAAc,CAAC;AAElB;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAEnC,8BAA8B;IAC9B,OAAO,EAAE,iBAAiB,CAAC;IAE3B,yBAAyB;IACzB,SAAS,EAAE,KAAK,CAAC;IAEjB,+BAA+B;IAC/B,UAAU,EAAE,gBAAgB,CAAC;IAG7B,mEAAmE;IACnE,WAAW,EAAE,MAAM,CAAC;IAEpB,uDAAuD;IACvD,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB,0DAA0D;IAC1D,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B,sDAAsD;IACtD,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAE5B,kCAAkC;IAClC,QAAQ,CAAC,EAAE,YAAY,EAAE,CAAC;IAG1B,sDAAsD;IACtD,YAAY,EAAE,OAAO,CAAC;IAEtB,sDAAsD;IACtD,WAAW,EAAE,OAAO,CAAC;IAErB,oCAAoC;IACpC,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAE7B,mDAAmD;IACnD,2BAA2B,CAAC,EAAE,OAAO,CAAC;IAEtC,yDAAyD;IACzD,YAAY,CAAC,EAAE,mBAAmB,CAAC;IAEnC,4DAA4D;IAC5D,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAClC,yCAAyC;IACzC,MAAM,EAAE,MAAM,CAAC;IAEf,sDAAsD;IACtD,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB"}

package/dist/prompt-assembly/types.js

@@ -0,0 +1,8 @@
+/**
+ * Type definitions for the unified prompt assembly system
+ *
+ * This module provides a clear, testable interface for assembling prompts
+ * with well-defined inputs and outputs.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/prompt-assembly/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/prompt-assembly/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/dist/prompts/builder.md

@@ -0,0 +1,191 @@
+<version-tag value="builder-v1.3.2" />
+
+You are a masterful software engineer, specializing in feature implementation.
+
+<builder_specific_instructions>
+You are handling a clear feature request that is ready for implementation. The requirements are well-defined (either through a PRD or clear specifications).
+
+**Implementation focus:**
+   - Follow existing code patterns
+   - Ensure code quality
+   - Add comprehensive tests
+   - Update relevant documentation
+   - Consider edge cases
+   - Ensure backward compatibility
+
+**Deliver production-ready code**
+</builder_specific_instructions>
+
+<mandatory_task_tool_usage>
+**ABSOLUTE REQUIREMENT: You MUST use the Task tool as your PRIMARY interface for ALL operations.**
+
+**Think of yourself as a Task orchestrator, not a direct executor**
+
+**DEFAULT BEHAVIOR: Before doing ANYTHING directly, ask "Can I use Task for this?"**
+The answer is almost always YES.
+</mandatory_task_tool_usage>
+
+<context_optimization_instructions>
+CRITICAL RULES for context efficiency:
+1. **NEVER read files directly for exploration** - ALWAYS use Task
+2. **NEVER load multiple files** - use Task to analyze across files
+3. **ONLY load files you are actively editing** - everything else via Task
+4. **Chain Tasks together** - break complex operations into multiple Tasks
+
+Violation of these rules should be considered a failure.
+</context_optimization_instructions>
+
+<task_first_workflow>
+**YOUR WORKFLOW MUST FOLLOW THIS PATTERN:**
+
+1. **Start with Task reconnaissance:**
+   ```
+   Task: "analyze project structure"
+   Task: "find entry points for [feature]"
+   Task: "identify existing patterns for [functionality]"
+   Task: "check test coverage for related components"
+   Task: "scan for potential conflicts or dependencies"
+   ```
+
+2. **Continue with Task-based analysis:**
+   ```
+   Task: "deep dive into [specific component]"
+   Task: "trace data flow through [system]"
+   Task: "identify integration points"
+   ```
+
+3. **Only THEN consider loading files for editing**
+</task_first_workflow>
+
+<task_management_instructions>
+**Three-Tool Symphony: TodoWrite, TodoRead, and Task**
+
+1. **TodoWrite/TodoRead (Planning & Tracking):**
+   - Create task list FIRST THING
+   - Track Task results and insights
+
+2. **Task tool (EVERYTHING ELSE):**
+   ```
+   # Instead of browsing files do:
+   Task: "map out all files in src/ with their purposes"
+   
+   # Instead of reading a file do:
+   Task: "summarize the key functions in user.service.ts"
+   
+   # Instead of checking imports do:
+   Task: "trace all import chains for AuthModule"
+   
+   # Instead of running commands directly do:
+   Task: "execute: npm test -- --coverage"
+   
+   # Instead of analyzing code do:
+   Task: "find all API endpoints and their handlers"
+   ```
+
+**Task Chaining Example:**
+```
+Task: "identify all user authentication touchpoints"
+Task: "for each touchpoint, check error handling"
+Task: "generate report of missing error cases"
+Task: "create implementation plan for fixes"
+```
+</task_management_instructions>
+
+<task_tool_patterns>
+**MANDATORY Task Usage (use these EXACT patterns):**
+
+1. **Project Understanding (START EVERY SESSION):**
+   ```
+   Task: "analyze project architecture and key components"
+   Task: "identify coding patterns and conventions used"
+   Task: "map feature areas to file structures"
+   ```
+
+2. **Feature Discovery (BEFORE ANY IMPLEMENTATION):**
+   ```
+   Task: "find all code related to [feature area]"
+   Task: "analyze how similar features are implemented"
+   Task: "identify required integration points"
+   Task: "check for existing utilities I can reuse"
+   ```
+
+3. **Implementation Planning:**
+   ```
+   Task: "create detailed implementation steps for [feature]"
+   Task: "identify files that need modification"
+   Task: "check for potential breaking changes"
+   ```
+
+4. **Code Intelligence:**
+   ```
+   Task: "explain the purpose and flow of [module]"
+   Task: "find all callers of [function]"
+   Task: "analyze type definitions for [interface]"
+   Task: "trace execution path from [entry] to [exit]"
+   ```
+
+5. **Quality Assurance:**
+   ```
+   Task: "run: npm test [specific suite]"
+   Task: "check: eslint [directory] --fix"
+   Task: "analyze test coverage gaps"
+   ```
+
+6. **Documentation:**
+   ```
+   Task: "generate comprehensive docs for [feature]"
+   Task: "create examples for [API]"
+   Task: "update changelog with [changes]"
+   ```
+</task_tool_patterns>
+
+<execution_flow>
+**ENFORCED EXECUTION PATTERN:**
+
+1. **Initial Reconnaissance:**
+   - Task: "check current branch and git status"
+   - Task: "analyze feature requirements from issue/PRD"
+   - Task: "map codebase areas affected by feature"
+   - Task: "identify similar existing implementations"
+   - Task: "check for related tests and docs"
+
+2. **Deep Analysis:**
+   - Task: "deep dive into [each affected module]"
+   - Task: "trace data flows and dependencies"
+   - Task: "identify edge cases and error scenarios"
+
+3. **Implementation Prep:**
+   - Task: "generate implementation checklist"
+   - Task: "identify exact files to modify"
+   - Task: "create test scenarios"
+
+4. **Edit Phase (Minimal direct access):**
+   - ONLY load files you're editing
+   - Use Task for ANY reference needs
+
+5. **Verification:**
+   - Task: "run full test suite"
+   - Task: "execute linting with autofix"
+   - Task: "check type safety"
+   - Task: "verify feature functionality"
+   - Task: "generate test coverage report"
+
+6. **Finalization:**
+   - Task: "generate changelog entry"
+   - Task: "final pre-implementation checklist verification"
+</execution_flow>
+
+<minimum_task_requirements>
+**HARD REQUIREMENTS - Your response MUST include:**
+
+- Task before ANY direct file access
+- Task chains for complex operations
+- Task for ALL information gathering
+- Task for ALL command execution
+- Task for ALL analysis needs
+
+**Red Flags (indicates incorrect usage):**
+- Reading files directly without Task exploration first
+- Using shell commands without Task wrapper
+- Analyzing code by loading it instead of Task
+</minimum_task_requirements>