@supaku/agentfactory-server 0.7.9 → 0.7.10

package/dist/src/agent-tracking.d.ts

@@ -28,6 +28,86 @@ export interface QAAttemptRecord {
         reason?: string;
     }>;
 }
+/**
+ * Escalation strategy computed deterministically from cycleCount.
+ * No LLM in the decision loop — pure function.
+ */
+export type EscalationStrategy = 'normal' | 'context-enriched' | 'decompose' | 'escalate-human';
+/**
+ * Workflow phase types
+ */
+export type WorkflowPhase = 'development' | 'qa' | 'refinement' | 'acceptance';
+/**
+ * Record of a single phase attempt within a workflow cycle
+ */
+export interface PhaseRecord {
+    attempt: number;
+    sessionId?: string;
+    startedAt: number;
+    completedAt?: number;
+    result?: 'passed' | 'failed' | 'unknown';
+    failureReason?: string;
+    costUsd?: number;
+}
+/**
+ * Cross-phase workflow state for an issue.
+ * Tracks the full dev-QA-rejected cycle count and accumulated failure context.
+ * Higher-level overlay on top of the existing QAAttemptRecord.
+ */
+export interface WorkflowState {
+    issueId: string;
+    issueIdentifier: string;
+    cycleCount: number;
+    phases: {
+        development: PhaseRecord[];
+        qa: PhaseRecord[];
+        refinement: PhaseRecord[];
+        acceptance: PhaseRecord[];
+    };
+    strategy: EscalationStrategy;
+    failureSummary: string | null;
+    createdAt: number;
+    updatedAt: number;
+}
+/**
+ * Compute escalation strategy deterministically from cycle count.
+ * Pure function — no side effects, no LLM.
+ */
+export declare function computeStrategy(cycleCount: number): EscalationStrategy;
+/**
+ * Get the workflow state for an issue
+ */
+export declare function getWorkflowState(issueId: string): Promise<WorkflowState | null>;
+/**
+ * Update (partial merge) the workflow state for an issue.
+ * Creates the state if it doesn't exist.
+ */
+export declare function updateWorkflowState(issueId: string, partial: Partial<Omit<WorkflowState, 'issueId'>> & {
+    issueIdentifier?: string;
+}): Promise<WorkflowState>;
+/**
+ * Record a phase attempt in the workflow state
+ */
+export declare function recordPhaseAttempt(issueId: string, phase: WorkflowPhase, record: PhaseRecord): Promise<WorkflowState>;
+/**
+ * Increment the dev-QA-rejected cycle count and recompute strategy.
+ * Called when QA or acceptance fails and triggers a Rejected transition.
+ */
+export declare function incrementCycleCount(issueId: string): Promise<WorkflowState>;
+/**
+ * Append a failure reason to the accumulated failure summary.
+ * Format: --- Cycle {N}, {phase} Attempt {M} ({timestamp}) ---\n{reason}
+ */
+export declare function appendFailureSummary(issueId: string, newFailure: string): Promise<WorkflowState>;
+/**
+ * Clear workflow state for an issue (called on acceptance pass)
+ */
+export declare function clearWorkflowState(issueId: string): Promise<void>;
+/**
+ * Extract a structured failure reason from an agent's result message.
+ * Strips boilerplate and keeps the substantive failure description.
+ */
+export declare function extractFailureReason(resultMessage: string | undefined): string;
 /**
  * Mark an issue as having been worked on by the agent
  */

package/dist/src/agent-tracking.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-tracking.d.ts","sourceRoot":"","sources":["../../src/agent-tracking.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAyBH;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAA;IACf,eAAe,EAAE,MAAM,CAAA;IACvB,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAA;IACf,aAAa,EAAE,MAAM,CAAA;IACrB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,gBAAgB,EAAE,KAAK,CAAC;QACtB,SAAS,EAAE,MAAM,CAAA;QACjB,QAAQ,EAAE,MAAM,CAAA;QAChB,MAAM,CAAC,EAAE,MAAM,CAAA;KAChB,CAAC,CAAA;CACH;AAED;;GAEG;AACH,wBAAsB,eAAe,CACnC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,IAAI,CAAC,eAAe,EAAE,SAAS,GAAG,aAAa,CAAC,GACrD,OAAO,CAAC,IAAI,CAAC,CAYf;AAED;;GAEG;AACH,wBAAsB,cAAc,CAClC,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAGjC;AAED;;GAEG;AACH,wBAAsB,eAAe,CACnC,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,eAAe,CAAC,CA2B1B;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAIxE;AAED;;GAEG;AACH,wBAAsB,YAAY,CAChC,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,IAAI,CAAC,CAIf;AAED;;GAEG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAGrE;AAED;;GAEG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAIlE;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAIrE;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAIpE;AAED;;;GAGG;AACH,wBAAsB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAI1E;AAED;;GAEG;AACH,wBAAsB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAG/E;AAED;;GAEG;AACH,wBAAsB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAI3E;AAED;;;GAGG;AACH,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAIzE;AAED;;GAEG;AACH,wBAAsB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAG9E;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAI1E;AAED;;;GAGG;AACH,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAWzE"}
+{"version":3,"file":"agent-tracking.d.ts","sourceRoot":"","sources":["../../src/agent-tracking.ts"],"names":[],"mappings":"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"}

package/dist/src/agent-tracking.js

@@ -17,12 +17,130 @@ const QA_ATTEMPT_PREFIX = 'qa:attempt:';
 const QA_FAILED_PREFIX = 'qa:failed:';
 const DEV_QUEUED_PREFIX = 'agent:dev-queued:';
 const ACCEPTANCE_QUEUED_PREFIX = 'agent:acceptance-queued:';
+const WORKFLOW_STATE_PREFIX = 'workflow:state:';
 // TTLs in seconds
 const AGENT_WORKED_TTL = 7 * 24 * 60 * 60; // 7 days
 const QA_ATTEMPT_TTL = 24 * 60 * 60; // 24 hours
 const QA_FAILED_TTL = 60 * 60; // 1 hour
 const DEV_QUEUED_TTL = 10; // 10 seconds - just enough to prevent duplicate webhooks
 const ACCEPTANCE_QUEUED_TTL = 10; // 10 seconds - just enough to prevent duplicate webhooks
+const WORKFLOW_STATE_TTL = 30 * 24 * 60 * 60; // 30 days
+/**
+ * Compute escalation strategy deterministically from cycle count.
+ * Pure function — no side effects, no LLM.
+ */
+export function computeStrategy(cycleCount) {
+    if (cycleCount <= 1)
+        return 'normal';
+    if (cycleCount === 2)
+        return 'context-enriched';
+    if (cycleCount === 3)
+        return 'decompose';
+    return 'escalate-human';
+}
+/**
+ * Get the workflow state for an issue
+ */
+export async function getWorkflowState(issueId) {
+    const key = `${WORKFLOW_STATE_PREFIX}${issueId}`;
+    return redisGet(key);
+}
+/**
+ * Update (partial merge) the workflow state for an issue.
+ * Creates the state if it doesn't exist.
+ */
+export async function updateWorkflowState(issueId, partial) {
+    const key = `${WORKFLOW_STATE_PREFIX}${issueId}`;
+    const existing = await redisGet(key);
+    const state = {
+        issueId,
+        issueIdentifier: partial.issueIdentifier ?? existing?.issueIdentifier ?? '',
+        cycleCount: partial.cycleCount ?? existing?.cycleCount ?? 0,
+        phases: {
+            development: partial.phases?.development ?? existing?.phases?.development ?? [],
+            qa: partial.phases?.qa ?? existing?.phases?.qa ?? [],
+            refinement: partial.phases?.refinement ?? existing?.phases?.refinement ?? [],
+            acceptance: partial.phases?.acceptance ?? existing?.phases?.acceptance ?? [],
+        },
+        strategy: partial.strategy ?? existing?.strategy ?? 'normal',
+        failureSummary: partial.failureSummary !== undefined ? partial.failureSummary : (existing?.failureSummary ?? null),
+        createdAt: existing?.createdAt ?? Date.now(),
+        updatedAt: Date.now(),
+    };
+    await redisSet(key, state, WORKFLOW_STATE_TTL);
+    return state;
+}
+/**
+ * Record a phase attempt in the workflow state
+ */
+export async function recordPhaseAttempt(issueId, phase, record) {
+    const existing = await getWorkflowState(issueId);
+    const phases = existing?.phases ?? { development: [], qa: [], refinement: [], acceptance: [] };
+    phases[phase] = [...phases[phase], record];
+    return updateWorkflowState(issueId, { phases });
+}
+/**
+ * Increment the dev-QA-rejected cycle count and recompute strategy.
+ * Called when QA or acceptance fails and triggers a Rejected transition.
+ */
+export async function incrementCycleCount(issueId) {
+    const existing = await getWorkflowState(issueId);
+    const newCount = (existing?.cycleCount ?? 0) + 1;
+    const strategy = computeStrategy(newCount);
+    log.info('Workflow cycle incremented', { issueId, cycleCount: newCount, strategy });
+    return updateWorkflowState(issueId, { cycleCount: newCount, strategy });
+}
+/**
+ * Append a failure reason to the accumulated failure summary.
+ * Format: --- Cycle {N}, {phase} Attempt {M} ({timestamp}) ---\n{reason}
+ */
+export async function appendFailureSummary(issueId, newFailure) {
+    const existing = await getWorkflowState(issueId);
+    const currentSummary = existing?.failureSummary ?? '';
+    const updatedSummary = currentSummary
+        ? `${currentSummary}\n\n${newFailure}`
+        : newFailure;
+    return updateWorkflowState(issueId, { failureSummary: updatedSummary });
+}
+/**
+ * Clear workflow state for an issue (called on acceptance pass)
+ */
+export async function clearWorkflowState(issueId) {
+    const key = `${WORKFLOW_STATE_PREFIX}${issueId}`;
+    await redisDel(key);
+    log.info('Cleared workflow state', { issueId });
+}
+/**
+ * Extract a structured failure reason from an agent's result message.
+ * Strips boilerplate and keeps the substantive failure description.
+ */
+export function extractFailureReason(resultMessage) {
+    if (!resultMessage)
+        return 'No result message provided';
+    // Try to extract from structured sections
+    const failurePatterns = [
+        /##\s*(?:QA\s+)?(?:Failed|Failure|Issues?\s+Found)[^\n]*\n([\s\S]*?)(?=\n##|\n<!--|\Z)/i,
+        /(?:Fail(?:ure|ed)\s+(?:Reason|Details?|Summary)):?\s*([\s\S]*?)(?=\n##|\n<!--|\Z)/i,
+        /(?:Issues?\s+Found|Problems?\s+Found):?\s*([\s\S]*?)(?=\n##|\n<!--|\Z)/i,
+    ];
+    for (const pattern of failurePatterns) {
+        const match = resultMessage.match(pattern);
+        if (match?.[1]) {
+            const extracted = match[1].trim();
+            if (extracted.length > 20) {
+                // Truncate if excessively long
+                return extracted.length > 2000 ? extracted.slice(0, 2000) + '...' : extracted;
+            }
+        }
+    }
+    // Fallback: take the last meaningful paragraph (often the conclusion)
+    const paragraphs = resultMessage.split(/\n\n+/).filter(p => p.trim().length > 20);
+    if (paragraphs.length > 0) {
+        const last = paragraphs[paragraphs.length - 1].trim();
+        return last.length > 2000 ? last.slice(0, 2000) + '...' : last;
+    }
+    return resultMessage.slice(0, 500);
+}
 /**
  * Mark an issue as having been worked on by the agent
  */
@@ -179,6 +297,7 @@ export async function cleanupAcceptedIssue(issueId) {
         `${QA_FAILED_PREFIX}${issueId}`,
         `${DEV_QUEUED_PREFIX}${issueId}`,
         `${ACCEPTANCE_QUEUED_PREFIX}${issueId}`,
+        `${WORKFLOW_STATE_PREFIX}${issueId}`,
     ];
     await Promise.all(keysToDelete.map((key) => redisDel(key)));
     log.info('Cleaned up all tracking data for accepted issue', { issueId });

package/dist/src/governor-storage.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Governor Storage — Redis Implementation
+ *
+ * Redis-backed storage adapter for the human touchpoint override state.
+ * Implements the OverrideStorage interface from @supaku/agentfactory (packages/core).
+ */
+import type { OverrideStorage, OverrideState } from '@supaku/agentfactory';
+/**
+ * Redis-backed override storage for production use.
+ *
+ * Stores override state under `governor:override:{issueId}` keys
+ * with a 30-day TTL.
+ */
+export declare class RedisOverrideStorage implements OverrideStorage {
+    /**
+     * Get the override state for an issue from Redis
+     */
+    get(issueId: string): Promise<OverrideState | null>;
+    /**
+     * Persist override state for an issue to Redis
+     */
+    set(issueId: string, state: OverrideState): Promise<void>;
+    /**
+     * Remove override state for an issue from Redis
+     */
+    clear(issueId: string): Promise<void>;
+}
+//# sourceMappingURL=governor-storage.d.ts.map

package/dist/src/governor-storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"governor-storage.d.ts","sourceRoot":"","sources":["../../src/governor-storage.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAgB1E;;;;;GAKG;AACH,qBAAa,oBAAqB,YAAW,eAAe;IAC1D;;OAEG;IACG,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;IAWzD;;OAEG;IACG,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAM/D;;OAEG;IACG,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAK5C"}

package/dist/src/governor-storage.js

@@ -0,0 +1,52 @@
+/**
+ * Governor Storage — Redis Implementation
+ *
+ * Redis-backed storage adapter for the human touchpoint override state.
+ * Implements the OverrideStorage interface from @supaku/agentfactory (packages/core).
+ */
+import { redisSet, redisGet, redisDel } from './redis.js';
+const log = {
+    info: (msg, data) => console.log(`[governor-storage] ${msg}`, data ? JSON.stringify(data) : ''),
+    warn: (msg, data) => console.warn(`[governor-storage] ${msg}`, data ? JSON.stringify(data) : ''),
+    error: (msg, data) => console.error(`[governor-storage] ${msg}`, data ? JSON.stringify(data) : ''),
+    debug: (_msg, _data) => { },
+};
+/** Redis key prefix for governor override state */
+const GOVERNOR_OVERRIDE_PREFIX = 'governor:override:';
+/** TTL for override state: 30 days in seconds */
+const GOVERNOR_OVERRIDE_TTL = 30 * 24 * 60 * 60;
+/**
+ * Redis-backed override storage for production use.
+ *
+ * Stores override state under `governor:override:{issueId}` keys
+ * with a 30-day TTL.
+ */
+export class RedisOverrideStorage {
+    /**
+     * Get the override state for an issue from Redis
+     */
+    async get(issueId) {
+        const key = `${GOVERNOR_OVERRIDE_PREFIX}${issueId}`;
+        const state = await redisGet(key);
+        if (state) {
+            log.debug('Retrieved override state', { issueId, type: state.directive.type });
+        }
+        return state;
+    }
+    /**
+     * Persist override state for an issue to Redis
+     */
+    async set(issueId, state) {
+        const key = `${GOVERNOR_OVERRIDE_PREFIX}${issueId}`;
+        await redisSet(key, state, GOVERNOR_OVERRIDE_TTL);
+        log.info('Stored override state', { issueId, type: state.directive.type });
+    }
+    /**
+     * Remove override state for an issue from Redis
+     */
+    async clear(issueId) {
+        const key = `${GOVERNOR_OVERRIDE_PREFIX}${issueId}`;
+        await redisDel(key);
+        log.info('Cleared override state', { issueId });
+    }
+}

package/dist/src/index.d.ts

@@ -14,4 +14,6 @@ export * from './session-hash.js';
 export * from './rate-limit.js';
 export * from './token-storage.js';
 export * from './env-validation.js';
+export * from './governor-storage.js';
+export * from './processing-state-storage.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,cAAc,aAAa,CAAA;AAG3B,cAAc,YAAY,CAAA;AAG1B,cAAc,YAAY,CAAA;AAG1B,cAAc,sBAAsB,CAAA;AAGpC,cAAc,iBAAiB,CAAA;AAG/B,cAAc,qBAAqB,CAAA;AAGnC,cAAc,iBAAiB,CAAA;AAG/B,cAAc,qBAAqB,CAAA;AAGnC,cAAc,0BAA0B,CAAA;AAGxC,cAAc,sBAAsB,CAAA;AAGpC,cAAc,qBAAqB,CAAA;AAGnC,cAAc,kBAAkB,CAAA;AAGhC,cAAc,mBAAmB,CAAA;AAGjC,cAAc,iBAAiB,CAAA;AAG/B,cAAc,oBAAoB,CAAA;AAGlC,cAAc,qBAAqB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,cAAc,aAAa,CAAA;AAG3B,cAAc,YAAY,CAAA;AAG1B,cAAc,YAAY,CAAA;AAG1B,cAAc,sBAAsB,CAAA;AAGpC,cAAc,iBAAiB,CAAA;AAG/B,cAAc,qBAAqB,CAAA;AAGnC,cAAc,iBAAiB,CAAA;AAG/B,cAAc,qBAAqB,CAAA;AAGnC,cAAc,0BAA0B,CAAA;AAGxC,cAAc,sBAAsB,CAAA;AAGpC,cAAc,qBAAqB,CAAA;AAGnC,cAAc,kBAAkB,CAAA;AAGhC,cAAc,mBAAmB,CAAA;AAGjC,cAAc,iBAAiB,CAAA;AAG/B,cAAc,oBAAoB,CAAA;AAGlC,cAAc,qBAAqB,CAAA;AAGnC,cAAc,uBAAuB,CAAA;AAGrC,cAAc,+BAA+B,CAAA"}

package/dist/src/index.js

@@ -30,3 +30,7 @@ export * from './rate-limit.js';
 export * from './token-storage.js';
 // Environment validation
 export * from './env-validation.js';
+// Governor storage (Redis-backed override state)
+export * from './governor-storage.js';
+// Processing state storage (Redis-backed top-of-funnel phase tracking)
+export * from './processing-state-storage.js';

package/dist/src/processing-state-storage.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Redis-backed Processing State Storage
+ *
+ * Implements the `ProcessingStateStorage` interface from `@supaku/agentfactory`
+ * using Redis for persistence. Used by the top-of-funnel governor to track
+ * which processing phases (research, backlog-creation) have been completed
+ * for each issue.
+ *
+ * Key format: `governor:processing:{issueId}:{phase}`
+ * TTL: 30 days (matches workflow state TTL)
+ */
+import type { ProcessingStateStorage, ProcessingPhase, ProcessingRecord } from '@supaku/agentfactory';
+/**
+ * Redis-backed implementation of `ProcessingStateStorage`.
+ *
+ * Each phase completion is stored as an independent key so that phases
+ * can be checked and cleared independently without affecting each other.
+ */
+export declare class RedisProcessingStateStorage implements ProcessingStateStorage {
+    /**
+     * Check whether a given phase has already been completed for an issue.
+     */
+    isPhaseCompleted(issueId: string, phase: ProcessingPhase): Promise<boolean>;
+    /**
+     * Mark a phase as completed for an issue.
+     * Stores a `ProcessingRecord` JSON object with a 30-day TTL.
+     */
+    markPhaseCompleted(issueId: string, phase: ProcessingPhase, sessionId?: string): Promise<void>;
+    /**
+     * Clear a phase completion record for an issue.
+     */
+    clearPhase(issueId: string, phase: ProcessingPhase): Promise<void>;
+    /**
+     * Retrieve the processing record for a phase, if it exists.
+     */
+    getPhaseRecord(issueId: string, phase: ProcessingPhase): Promise<ProcessingRecord | null>;
+}
+//# sourceMappingURL=processing-state-storage.d.ts.map

package/dist/src/processing-state-storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"processing-state-storage.d.ts","sourceRoot":"","sources":["../../src/processing-state-storage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EACV,sBAAsB,EACtB,eAAe,EACf,gBAAgB,EACjB,MAAM,sBAAsB,CAAA;AAgB7B;;;;;GAKG;AACH,qBAAa,2BAA4B,YAAW,sBAAsB;IACxE;;OAEG;IACG,gBAAgB,CACpB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,eAAe,GACrB,OAAO,CAAC,OAAO,CAAC;IAInB;;;OAGG;IACG,kBAAkB,CACtB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,eAAe,EACtB,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,IAAI,CAAC;IAUhB;;OAEG;IACG,UAAU,CACd,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,eAAe,GACrB,OAAO,CAAC,IAAI,CAAC;IAIhB;;OAEG;IACG,cAAc,CAClB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,eAAe,GACrB,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC;CAGpC"}

package/dist/src/processing-state-storage.js

@@ -0,0 +1,61 @@
+/**
+ * Redis-backed Processing State Storage
+ *
+ * Implements the `ProcessingStateStorage` interface from `@supaku/agentfactory`
+ * using Redis for persistence. Used by the top-of-funnel governor to track
+ * which processing phases (research, backlog-creation) have been completed
+ * for each issue.
+ *
+ * Key format: `governor:processing:{issueId}:{phase}`
+ * TTL: 30 days (matches workflow state TTL)
+ */
+import { redisSet, redisGet, redisDel, redisExists } from './redis.js';
+// Redis key prefix for processing state records
+const PROCESSING_STATE_PREFIX = 'governor:processing:';
+// 30-day TTL in seconds
+const PROCESSING_STATE_TTL = 30 * 24 * 60 * 60;
+/**
+ * Build the Redis key for a specific issue + phase combination.
+ */
+function redisKey(issueId, phase) {
+    return `${PROCESSING_STATE_PREFIX}${issueId}:${phase}`;
+}
+/**
+ * Redis-backed implementation of `ProcessingStateStorage`.
+ *
+ * Each phase completion is stored as an independent key so that phases
+ * can be checked and cleared independently without affecting each other.
+ */
+export class RedisProcessingStateStorage {
+    /**
+     * Check whether a given phase has already been completed for an issue.
+     */
+    async isPhaseCompleted(issueId, phase) {
+        return redisExists(redisKey(issueId, phase));
+    }
+    /**
+     * Mark a phase as completed for an issue.
+     * Stores a `ProcessingRecord` JSON object with a 30-day TTL.
+     */
+    async markPhaseCompleted(issueId, phase, sessionId) {
+        const record = {
+            issueId,
+            phase,
+            completedAt: Date.now(),
+            sessionId,
+        };
+        await redisSet(redisKey(issueId, phase), record, PROCESSING_STATE_TTL);
+    }
+    /**
+     * Clear a phase completion record for an issue.
+     */
+    async clearPhase(issueId, phase) {
+        await redisDel(redisKey(issueId, phase));
+    }
+    /**
+     * Retrieve the processing record for a phase, if it exists.
+     */
+    async getPhaseRecord(issueId, phase) {
+        return redisGet(redisKey(issueId, phase));
+    }
+}

package/dist/src/workflow-state-integration.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=workflow-state-integration.test.d.ts.map

package/dist/src/workflow-state-integration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-state-integration.test.d.ts","sourceRoot":"","sources":["../../src/workflow-state-integration.test.ts"],"names":[],"mappings":""}

package/dist/src/workflow-state-integration.test.js

@@ -0,0 +1,281 @@
+/**
+ * Integration tests for the 4-cycle workflow state progression
+ * and escalate-human circuit breaker.
+ *
+ * Mocks Redis to test the full lifecycle:
+ *   Cycle 1 (normal) → Cycle 2 (context-enriched) → Cycle 3 (decompose) → Cycle 4 (escalate-human)
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+// In-memory Redis store for testing
+const store = new Map();
+vi.mock('./redis.js', () => ({
+    redisSet: vi.fn(async (key, value, _ttl) => {
+        store.set(key, JSON.stringify(value));
+    }),
+    redisGet: vi.fn(async (key) => {
+        const val = store.get(key);
+        return val ? JSON.parse(val) : null;
+    }),
+    redisDel: vi.fn(async (key) => {
+        const existed = store.has(key) ? 1 : 0;
+        store.delete(key);
+        return existed;
+    }),
+    redisExists: vi.fn(async (key) => store.has(key)),
+}));
+import { computeStrategy, getWorkflowState, updateWorkflowState, recordPhaseAttempt, incrementCycleCount, appendFailureSummary, clearWorkflowState, extractFailureReason, } from './agent-tracking.js';
+beforeEach(() => {
+    store.clear();
+});
+/**
+ * Simulate what the webhook-orchestrator onAgentComplete handler does
+ * when a QA/acceptance agent fails.
+ */
+async function simulateQAFailure(issueId, failureMessage) {
+    const state = await incrementCycleCount(issueId);
+    const failureReason = extractFailureReason(failureMessage);
+    const formattedFailure = `--- Cycle ${state.cycleCount}, qa (${new Date().toISOString()}) ---\n${failureReason}`;
+    await appendFailureSummary(issueId, formattedFailure);
+    return await getWorkflowState(issueId);
+}
+/**
+ * Simulate what the webhook-orchestrator onAgentComplete handler does
+ * when recording a phase attempt.
+ */
+async function simulatePhaseCompletion(issueId, phase, result, costUsd = 0.50) {
+    await recordPhaseAttempt(issueId, phase, {
+        attempt: 1,
+        sessionId: `session-${phase}-${Date.now()}`,
+        startedAt: Date.now(),
+        completedAt: Date.now(),
+        result,
+        costUsd,
+    });
+}
+describe('4-cycle workflow progression integration', () => {
+    const issueId = 'test-issue-001';
+    const issueIdentifier = 'TEST-42';
+    it('progresses through all 4 escalation tiers across full dev-QA-rejected cycles', async () => {
+        // Initialize workflow state (happens on first agent completion)
+        await updateWorkflowState(issueId, { issueIdentifier });
+        // === Cycle 1: normal ===
+        // Development completes, QA fails
+        await simulatePhaseCompletion(issueId, 'development', 'passed');
+        await simulatePhaseCompletion(issueId, 'qa', 'failed');
+        let state = await simulateQAFailure(issueId, '## QA Failed\n\nTests failed: TypeError in handleUserLogin — null check missing');
+        expect(state).not.toBeNull();
+        expect(state.cycleCount).toBe(1);
+        expect(state.strategy).toBe('normal');
+        expect(state.failureSummary).toContain('TypeError in handleUserLogin');
+        // At cycle 1 (normal), strategy would provide retry context for development
+        expect(computeStrategy(1)).toBe('normal');
+        // === Cycle 2: context-enriched ===
+        // Refinement completes, development re-runs, QA fails again
+        await simulatePhaseCompletion(issueId, 'refinement', 'passed');
+        await simulatePhaseCompletion(issueId, 'development', 'passed');
+        await simulatePhaseCompletion(issueId, 'qa', 'failed');
+        state = await simulateQAFailure(issueId, '## QA Failed\n\nBuild passes but integration test for /api/users returns 500. Missing database migration.');
+        expect(state.cycleCount).toBe(2);
+        expect(state.strategy).toBe('context-enriched');
+        expect(state.failureSummary).toContain('Cycle 1');
+        expect(state.failureSummary).toContain('Cycle 2');
+        expect(state.failureSummary).toContain('database migration');
+        // At cycle 2 (context-enriched), refinement gets full failure history
+        expect(computeStrategy(2)).toBe('context-enriched');
+        // === Cycle 3: decompose ===
+        await simulatePhaseCompletion(issueId, 'refinement', 'passed');
+        await simulatePhaseCompletion(issueId, 'development', 'passed');
+        await simulatePhaseCompletion(issueId, 'qa', 'failed');
+        state = await simulateQAFailure(issueId, 'Failure Reason: The same /api/users endpoint still returns 500. Root cause is the missing foreign key constraint in the migration.');
+        expect(state.cycleCount).toBe(3);
+        expect(state.strategy).toBe('decompose');
+        expect(state.failureSummary).toContain('Cycle 3');
+        // At cycle 3 (decompose), refinement gets decomposition instructions
+        expect(computeStrategy(3)).toBe('decompose');
+        // === Cycle 4: escalate-human ===
+        await simulatePhaseCompletion(issueId, 'refinement', 'passed');
+        await simulatePhaseCompletion(issueId, 'development', 'passed');
+        await simulatePhaseCompletion(issueId, 'qa', 'failed');
+        state = await simulateQAFailure(issueId, 'Issues Found:\n1. API endpoint still broken\n2. Migration file has syntax error\n3. Schema mismatch between ORM and SQL');
+        expect(state.cycleCount).toBe(4);
+        expect(state.strategy).toBe('escalate-human');
+        expect(state.failureSummary).toContain('Cycle 4');
+        // At cycle 4+ (escalate-human), the loop should stop entirely
+        expect(computeStrategy(state.cycleCount)).toBe('escalate-human');
+        expect(computeStrategy(state.cycleCount + 1)).toBe('escalate-human');
+        // Verify all 4 phase records tracked for development and QA
+        expect(state.phases.development).toHaveLength(4);
+        expect(state.phases.qa).toHaveLength(4);
+        expect(state.phases.refinement).toHaveLength(3);
+    });
+    it('accumulates failure summaries across all cycles with correct formatting', async () => {
+        await updateWorkflowState(issueId, { issueIdentifier });
+        // Simulate 4 failures with distinct messages
+        const failures = [
+            '## QA Failed\n\nNull pointer in UserService.getById',
+            'Failure Reason: Missing validation on email field causes 500',
+            'Issues Found:\n1. Race condition in session manager\n2. Stale cache returns wrong user',
+            '## QA Failed\n\nDatabase connection pool exhausted after 10 concurrent requests',
+        ];
+        for (const msg of failures) {
+            await simulateQAFailure(issueId, msg);
+        }
+        const state = await getWorkflowState(issueId);
+        expect(state).not.toBeNull();
+        expect(state.cycleCount).toBe(4);
+        expect(state.strategy).toBe('escalate-human');
+        // All 4 cycle markers should be present
+        expect(state.failureSummary).toContain('Cycle 1');
+        expect(state.failureSummary).toContain('Cycle 2');
+        expect(state.failureSummary).toContain('Cycle 3');
+        expect(state.failureSummary).toContain('Cycle 4');
+        // Failure details from each cycle should be present
+        expect(state.failureSummary).toContain('Null pointer in UserService');
+        expect(state.failureSummary).toContain('Missing validation on email');
+        expect(state.failureSummary).toContain('Race condition in session manager');
+        expect(state.failureSummary).toContain('Database connection pool exhausted');
+    });
+    it('tracks per-phase attempt records and costs across cycles', async () => {
+        await updateWorkflowState(issueId, { issueIdentifier });
+        // Cycle 1: dev → qa(fail)
+        await simulatePhaseCompletion(issueId, 'development', 'passed', 1.50);
+        await simulatePhaseCompletion(issueId, 'qa', 'failed', 0.75);
+        await simulateQAFailure(issueId, 'Tests failed');
+        // Cycle 2: refinement → dev → qa(fail)
+        await simulatePhaseCompletion(issueId, 'refinement', 'passed', 0.50);
+        await simulatePhaseCompletion(issueId, 'development', 'passed', 2.00);
+        await simulatePhaseCompletion(issueId, 'qa', 'failed', 0.80);
+        await simulateQAFailure(issueId, 'Build failed');
+        const state = await getWorkflowState(issueId);
+        expect(state).not.toBeNull();
+        // Check phase records exist
+        expect(state.phases.development).toHaveLength(2);
+        expect(state.phases.qa).toHaveLength(2);
+        expect(state.phases.refinement).toHaveLength(1);
+        expect(state.phases.acceptance).toHaveLength(0);
+        // Calculate total cost (simulates what the escalation comment builder does)
+        const allPhases = [
+            ...state.phases.development,
+            ...state.phases.qa,
+            ...state.phases.refinement,
+            ...state.phases.acceptance,
+        ];
+        const totalCost = allPhases.reduce((sum, p) => sum + (p.costUsd ?? 0), 0);
+        expect(totalCost).toBeCloseTo(5.55, 2);
+    });
+    it('clears workflow state on acceptance pass', async () => {
+        await updateWorkflowState(issueId, { issueIdentifier });
+        await simulateQAFailure(issueId, 'Tests failed');
+        let state = await getWorkflowState(issueId);
+        expect(state).not.toBeNull();
+        expect(state.cycleCount).toBe(1);
+        // Acceptance pass clears everything
+        await clearWorkflowState(issueId);
+        state = await getWorkflowState(issueId);
+        expect(state).toBeNull();
+    });
+    it('strategy-based circuit breaker blocks at cycle 4+', async () => {
+        await updateWorkflowState(issueId, { issueIdentifier });
+        // Progress to escalate-human (cycle 4)
+        for (let i = 0; i < 4; i++) {
+            await simulateQAFailure(issueId, `Failure in cycle ${i + 1}`);
+        }
+        const state = await getWorkflowState(issueId);
+        expect(state.strategy).toBe('escalate-human');
+        // Circuit breaker check: this is what issue-updated.ts does
+        const shouldBlock = state.strategy === 'escalate-human';
+        expect(shouldBlock).toBe(true);
+        // Verify further increments stay at escalate-human
+        await simulateQAFailure(issueId, 'Yet another failure');
+        const state2 = await getWorkflowState(issueId);
+        expect(state2.cycleCount).toBe(5);
+        expect(state2.strategy).toBe('escalate-human');
+    });
+});
+describe('escalate-human blocker creation data', () => {
+    const issueId = 'blocker-test-001';
+    const issueIdentifier = 'TEST-99';
+    it('provides correct data for blocker issue creation at cycle 4', async () => {
+        await updateWorkflowState(issueId, { issueIdentifier });
+        // Simulate 4 cycles with realistic failures
+        const qaFailures = [
+            '## QA Failed\n\nUnit tests in packages/core fail with TypeError: Cannot read property of undefined',
+            'Failure Reason: Integration test for webhook handler times out after 30s',
+            'Issues Found:\n1. Missing mock for Redis in test setup\n2. Race condition in async handler',
+            '## QA Failed\n\nTypecheck fails: Property "strategy" does not exist on type "WorkflowState"',
+        ];
+        for (const msg of qaFailures) {
+            await simulatePhaseCompletion(issueId, 'development', 'passed', 1.00);
+            await simulatePhaseCompletion(issueId, 'qa', 'failed', 0.50);
+            await simulateQAFailure(issueId, msg);
+        }
+        const state = await getWorkflowState(issueId);
+        expect(state).not.toBeNull();
+        expect(state.strategy).toBe('escalate-human');
+        expect(state.cycleCount).toBe(4);
+        // Verify the data that would be used to create the blocker issue
+        const { cycleCount, failureSummary, phases } = state;
+        // Blocker title matches what issue-updated.ts generates
+        const blockerTitle = `Human review needed: ${issueIdentifier} failed ${cycleCount} automated cycles`;
+        expect(blockerTitle).toBe('Human review needed: TEST-99 failed 4 automated cycles');
+        // Blocker description includes failure summary
+        const blockerDescription = [
+            `This issue has failed **${cycleCount} automated dev-QA-rejected cycles** and requires human intervention.`,
+            '',
+            '### Failure History',
+            failureSummary ?? 'No failure details recorded.',
+            '',
+            '---',
+            `*Source issue: ${issueIdentifier}*`,
+        ].join('\n');
+        expect(blockerDescription).toContain('4 automated dev-QA-rejected cycles');
+        expect(blockerDescription).toContain('TypeError: Cannot read property');
+        expect(blockerDescription).toContain('Race condition in async handler');
+        expect(blockerDescription).toContain('Source issue: TEST-99');
+        // Escalation comment includes total cost
+        const allPhases = [
+            ...phases.development,
+            ...phases.qa,
+            ...phases.refinement,
+            ...phases.acceptance,
+        ];
+        const totalCost = allPhases.reduce((sum, p) => sum + (p.costUsd ?? 0), 0);
+        expect(totalCost).toBeCloseTo(6.00, 2); // 4 × (1.00 + 0.50)
+        const costLine = totalCost > 0 ? `\n**Total cost across all attempts:** $${totalCost.toFixed(2)}` : '';
+        expect(costLine).toContain('$6.00');
+        // Escalation comment content
+        const escalationComment = `## Circuit Breaker: Human Intervention Required\n\n` +
+            `This issue has gone through **${cycleCount} dev-QA-rejected cycles** without passing.\n` +
+            `The automated system is stopping further attempts.\n` +
+            costLine +
+            `\n\n### Failure History\n\n${failureSummary ?? 'No failure details recorded.'}\n\n` +
+            `### Recommended Actions\n` +
+            `1. Review the failure patterns above\n` +
+            `2. Consider if the acceptance criteria need clarification\n` +
+            `3. Investigate whether there's an architectural issue\n` +
+            `4. Manually fix or decompose the issue before re-enabling automation`;
+        expect(escalationComment).toContain('4 dev-QA-rejected cycles');
+        expect(escalationComment).toContain('$6.00');
+        expect(escalationComment).toContain('Cycle 1');
+        expect(escalationComment).toContain('Cycle 4');
+        expect(escalationComment).toContain('Recommended Actions');
+    });
+    it('verifies escalation strategy is deterministic and never regresses', async () => {
+        await updateWorkflowState(issueId, { issueIdentifier });
+        const expectedProgression = [
+            { cycle: 1, strategy: 'normal' },
+            { cycle: 2, strategy: 'context-enriched' },
+            { cycle: 3, strategy: 'decompose' },
+            { cycle: 4, strategy: 'escalate-human' },
+            { cycle: 5, strategy: 'escalate-human' },
+            { cycle: 6, strategy: 'escalate-human' },
+        ];
+        for (const { cycle, strategy } of expectedProgression) {
+            const state = await incrementCycleCount(issueId);
+            expect(state.cycleCount).toBe(cycle);
+            expect(state.strategy).toBe(strategy);
+            // Verify computeStrategy matches what's stored
+            expect(computeStrategy(state.cycleCount)).toBe(state.strategy);
+        }
+    });
+});

package/dist/src/workflow-state.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=workflow-state.test.d.ts.map

package/dist/src/workflow-state.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-state.test.d.ts","sourceRoot":"","sources":["../../src/workflow-state.test.ts"],"names":[],"mappings":""}

package/dist/src/workflow-state.test.js

@@ -0,0 +1,113 @@
+import { describe, it, expect } from 'vitest';
+import { computeStrategy, extractFailureReason } from './agent-tracking.js';
+describe('computeStrategy', () => {
+    it('returns normal for cycle 0', () => {
+        expect(computeStrategy(0)).toBe('normal');
+    });
+    it('returns normal for cycle 1', () => {
+        expect(computeStrategy(1)).toBe('normal');
+    });
+    it('returns context-enriched for cycle 2', () => {
+        expect(computeStrategy(2)).toBe('context-enriched');
+    });
+    it('returns decompose for cycle 3', () => {
+        expect(computeStrategy(3)).toBe('decompose');
+    });
+    it('returns escalate-human for cycle 4', () => {
+        expect(computeStrategy(4)).toBe('escalate-human');
+    });
+    it('returns escalate-human for cycle 5+', () => {
+        expect(computeStrategy(5)).toBe('escalate-human');
+        expect(computeStrategy(10)).toBe('escalate-human');
+        expect(computeStrategy(100)).toBe('escalate-human');
+    });
+});
+describe('extractFailureReason', () => {
+    it('returns default message for undefined input', () => {
+        expect(extractFailureReason(undefined)).toBe('No result message provided');
+    });
+    it('extracts from ## QA Failed section', () => {
+        const msg = `## QA Failed
+
+The build is broken because the new function does not handle null inputs correctly.
+Tests in packages/core are failing with TypeError.
+
+<!-- WORK_RESULT:failed -->`;
+        const result = extractFailureReason(msg);
+        expect(result).toContain('build is broken');
+        expect(result).toContain('null inputs');
+    });
+    it('extracts from Failure Reason: pattern', () => {
+        const msg = `QA Status: Failed
+
+Failure Reason: The API endpoint returns 500 when called with an empty payload. The validation middleware is not catching the missing required field.`;
+        const result = extractFailureReason(msg);
+        expect(result).toContain('API endpoint returns 500');
+    });
+    it('extracts from Issues Found pattern', () => {
+        const msg = `## QA Report
+
+Issues Found:
+1. Missing error handling in the login flow
+2. CSS layout broken on mobile viewport
+3. Unit test for UserService is failing`;
+        const result = extractFailureReason(msg);
+        expect(result).toContain('Missing error handling');
+    });
+    it('falls back to last paragraph for unstructured messages', () => {
+        const msg = `I looked at the code and ran the tests.
+
+Some things worked but others did not.
+
+The main issue is that the database migration was not applied correctly and the new column is missing from the users table, causing all queries to fail with a column not found error.`;
+        const result = extractFailureReason(msg);
+        expect(result).toContain('database migration');
+    });
+    it('truncates very long failure reasons', () => {
+        const longReason = 'x'.repeat(3000);
+        const msg = `## QA Failed\n${longReason}`;
+        const result = extractFailureReason(msg);
+        expect(result.length).toBeLessThanOrEqual(2003); // 2000 + '...'
+        expect(result.endsWith('...')).toBe(true);
+    });
+    it('handles short result messages gracefully', () => {
+        const msg = 'Failed';
+        const result = extractFailureReason(msg);
+        expect(result).toBe('Failed');
+    });
+});
+describe('escalation ladder progression', () => {
+    it('follows the correct strategy progression through 5 cycles', () => {
+        const expected = [
+            'normal', // cycle 0 (first attempt)
+            'normal', // cycle 1
+            'context-enriched', // cycle 2
+            'decompose', // cycle 3
+            'escalate-human', // cycle 4
+        ];
+        for (let cycle = 0; cycle < expected.length; cycle++) {
+            expect(computeStrategy(cycle)).toBe(expected[cycle]);
+        }
+    });
+    it('never returns a strategy weaker than escalate-human once reached', () => {
+        // Once at escalate-human, it stays there
+        for (let cycle = 4; cycle <= 20; cycle++) {
+            expect(computeStrategy(cycle)).toBe('escalate-human');
+        }
+    });
+    it('strategy always increases or stays at ceiling', () => {
+        const strategyOrder = {
+            'normal': 0,
+            'context-enriched': 1,
+            'decompose': 2,
+            'escalate-human': 3,
+        };
+        let previousLevel = -1;
+        for (let cycle = 0; cycle <= 10; cycle++) {
+            const strategy = computeStrategy(cycle);
+            const level = strategyOrder[strategy];
+            expect(level).toBeGreaterThanOrEqual(previousLevel);
+            previousLevel = level;
+        }
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supaku/agentfactory-server",
-  "version": "0.7.9",
+  "version": "0.7.10",
   "type": "module",
   "description": "Webhook server and distributed worker pool for AgentFactory — Redis queues, issue locks, session management",
   "author": "Supaku (https://supaku.com)",
@@ -44,8 +44,8 @@
   ],
   "dependencies": {
     "ioredis": "^5.4.2",
-    "@supaku/agentfactory": "0.7.9",
-    "@supaku/agentfactory-linear": "0.7.9"
+    "@supaku/agentfactory-linear": "0.7.10",
+    "@supaku/agentfactory": "0.7.10"
   },
   "devDependencies": {
     "@types/node": "^22.5.4",