@ai-sdlc/orchestrator 0.4.0 → 0.6.0

package/dist/triage.js

@@ -0,0 +1,133 @@
+/**
+ * Security triage pipeline — lightweight entry point that fetches an issue,
+ * runs the SecurityTriageRunner, posts findings as a comment, and applies
+ * a `rejected` or `triage-passed` label.
+ *
+ * **Asymmetric by design**: the triage agent can auto-reject issues above the
+ * risk threshold, but NEVER auto-approves (no `ai-ready` label).  A human
+ * must review the triage analysis and manually apply `ai-ready`.
+ */
+import { join } from 'node:path';
+import { loadConfigAsync } from './config.js';
+import { resolveIssueTrackerFromConfig } from './adapters.js';
+import { getGitHubConfig } from './shared.js';
+import { DEFAULT_CONFIG_DIR_NAME } from './defaults.js';
+import { SecurityTriageRunner, } from './runners/security-triage.js';
+import { createLogger } from './logger.js';
+// ── Labels ──────────────────────────────────────────────────────────
+const LABEL_REJECTED = 'security-rejected';
+const LABEL_TRIAGE_PASSED = 'triage-passed';
+// ── Comment formatting ──────────────────────────────────────────────
+function formatTriageComment(verdict, rejected) {
+    const icon = rejected ? '🚨' : verdict.riskScore >= 3 ? '⚠️' : '✅';
+    const status = rejected ? 'REJECTED' : 'PASSED';
+    const lines = [
+        `## ${icon} Security Triage: ${status}`,
+        '',
+        `**Risk Score:** ${verdict.riskScore}/10`,
+        `**Safe:** ${verdict.safe}`,
+        '',
+    ];
+    if (verdict.findings.length > 0) {
+        lines.push('### Findings', '');
+        for (const finding of verdict.findings) {
+            lines.push(`- ${finding}`);
+        }
+        lines.push('');
+    }
+    lines.push('### Rationale', '', verdict.rationale, '');
+    if (rejected) {
+        lines.push('---', '> This issue has been automatically rejected due to a high risk score.', '> A maintainer may override this by removing the `security-rejected` label', '> and manually applying `ai-ready` after review.');
+    }
+    else {
+        lines.push('---', '> This issue passed automated security triage.', '> A maintainer must still manually apply the `ai-ready` label to enable AI processing.');
+    }
+    lines.push('', '*Analyzed by [AI-SDLC Security Triage](https://github.com/ai-sdlc-framework/ai-sdlc)*');
+    return lines.join('\n');
+}
+// ── Pipeline ────────────────────────────────────────────────────────
+export async function executeTriage(issueId, options = {}) {
+    const workDir = options.workDir ?? process.cwd();
+    const log = options.logger ?? createLogger();
+    log.info(`[triage] Starting security triage for issue ${issueId}`);
+    // ── Resolve issue tracker ───────────────────────────────────────
+    let tracker;
+    if (options.tracker) {
+        tracker = options.tracker;
+    }
+    else {
+        const configDir = join(workDir, DEFAULT_CONFIG_DIR_NAME);
+        const config = await loadConfigAsync(configDir);
+        const ghConfig = getGitHubConfig();
+        tracker = resolveIssueTrackerFromConfig(config, {
+            org: ghConfig.org,
+            repo: ghConfig.repo,
+            token: { secretRef: 'GITHUB_TOKEN' },
+        });
+    }
+    // ── Fetch issue ─────────────────────────────────────────────────
+    const issue = await tracker.getIssue(issueId);
+    log.info(`[triage] Fetched issue: "${issue.title}"`);
+    // ── Run triage ──────────────────────────────────────────────────
+    const runner = new SecurityTriageRunner(options.triageConfig);
+    const agentResult = await runner.run({
+        issueId,
+        issueTitle: issue.title,
+        issueBody: issue.description ?? '',
+        workDir,
+        branch: 'main',
+        constraints: {
+            maxFilesPerChange: 0,
+            requireTests: false,
+            blockedPaths: ['**/*'],
+        },
+    });
+    if (!agentResult.success) {
+        log.error(`[triage] Triage failed: ${agentResult.error}`);
+        return {
+            issueId,
+            verdict: {
+                safe: false,
+                riskScore: 7,
+                findings: ['Triage pipeline error — treating as suspicious'],
+                sanitizedDescription: '',
+                rationale: agentResult.error ?? 'Unknown error',
+            },
+            rejected: true,
+            error: agentResult.error,
+        };
+    }
+    // ── Parse verdict ───────────────────────────────────────────────
+    const verdict = JSON.parse(agentResult.summary);
+    const rejected = verdict.riskScore >= runner.rejectThreshold;
+    log.info(`[triage] Verdict: riskScore=${verdict.riskScore}, safe=${verdict.safe}, rejected=${rejected}`);
+    // ── Post comment & apply label ──────────────────────────────────
+    if (!options.dryRun) {
+        const comment = formatTriageComment(verdict, rejected);
+        try {
+            await tracker.addComment(issueId, comment);
+            log.info(`[triage] Posted triage comment on issue ${issueId}`);
+        }
+        catch (err) {
+            log.error(`[triage] Failed to post comment: ${err}`);
+        }
+        const label = rejected ? LABEL_REJECTED : LABEL_TRIAGE_PASSED;
+        try {
+            const existingLabels = issue.labels ?? [];
+            await tracker.updateIssue(issueId, {
+                labels: [
+                    ...existingLabels.filter((l) => l !== LABEL_REJECTED && l !== LABEL_TRIAGE_PASSED),
+                    label,
+                ],
+            });
+            log.info(`[triage] Applied label "${label}" to issue ${issueId}`);
+            return { issueId, verdict, rejected, labelApplied: label };
+        }
+        catch (err) {
+            log.error(`[triage] Failed to apply label: ${err}`);
+            return { issueId, verdict, rejected, error: `Label application failed: ${err}` };
+        }
+    }
+    return { issueId, verdict, rejected };
+}
+//# sourceMappingURL=triage.js.map

package/dist/types.d.ts

@@ -3,7 +3,7 @@
  * Ensures all reference types are accessible through the orchestrator package
  * for downstream consumers without direct reference dependency.
  */
-export type { ApiVersion, Metadata, Condition, SecretRef, MetricCondition, Duration, Resource, TriggerFilter, Trigger, Provider, RoutingStrategy, ComplexityThreshold, Routing, Stage, PipelineSpec, PipelinePhase, PipelineStatus, Pipeline, AgentConstraints, HandoffContractRef, Handoff, SkillExample, Skill, AgentCard, AgentRoleSpec, AgentRoleStatus, AgentRole, GateScope, MetricRule, ToolRule, ReviewerRule, DocumentationRule, ProvenanceRule, ExpressionRule, GateRule, EnforcementLevel, Override, RetryPolicy, Evaluation, Gate, QualityGateSpec, QualityGateStatus, QualityGate, Permissions, ApprovalRequirement, Guardrails, MonitoringLevel, AutonomyLevel, PromotionCriteria, DemotionTrigger, AgentAutonomyStatus, AutonomyPolicySpec, AutonomyPolicyStatus, AutonomyPolicy, AdapterInterface, HealthCheck, AdapterBindingSpec, AdapterBindingStatus, AdapterBinding, AnyResource, ResourceKind, ValidationError, } from '@ai-sdlc/reference';
+export type { ApiVersion, Metadata, Condition, SecretRef, MetricCondition, Duration, Resource, TriggerFilter, Trigger, Provider, RoutingStrategy, ComplexityThreshold, Routing, Stage, PipelineSpec, PipelinePhase, PipelineStatus, Pipeline, AgentConstraints, HandoffContractRef, Handoff, SkillExample, Skill, AgentCard, AgentRoleSpec, AgentRoleStatus, AgentRole, GateScope, MetricRule, ToolRule, ReviewerRule, DocumentationRule, ProvenanceRule, ExpressionRule, GateRule, EnforcementLevel, Override, RetryPolicy, Evaluation, Gate, QualityGateSpec, QualityGateStatus, QualityGate, Permissions, ApprovalRequirement, Guardrails, MonitoringLevel, AutonomyLevel, PromotionCriteria, DemotionTrigger, AgentAutonomyStatus, AutonomyPolicySpec, AutonomyPolicyStatus, AutonomyPolicy, AdapterInterface, HealthCheck, AdapterBindingSpec, AdapterBindingStatus, AdapterBinding, AnyResource, ResourceKind, PriorityPolicy, PriorityDimensionConfig, PriorityDimensionsConfig, PriorityCalibrationConfig, PriorityAdaptersConfig, ValidationError, } from '@ai-sdlc/reference';
 export type { GateVerdict, DemotionResult, ComplexityFactor, AuthorizationContext, AuthorizationResult, AuthIdentity, AuthenticationResult, Authenticator, MutatingGateContext, ExpressionEvaluator, ExpressionVerdict, LLMEvaluationDimension, LLMEvaluationResult, LLMGateVerdict, } from '@ai-sdlc/reference';
 export type { AgentExecutionState, HandoffValidationError, SchemaResolver, SchemaValidationError, MemoryTier, MemoryEntry, WorkingMemory, ShortTermMemory, LongTermMemory, SharedMemory, EpisodicMemory, } from '@ai-sdlc/reference';
 //# sourceMappingURL=types.d.ts.map

package/dist/watch.d.ts

@@ -6,6 +6,8 @@
  */
 import { type ReconcilerConfig, type ReconcileResult, type Pipeline, type QualityGate, type AutonomyPolicy, type AgentRole, type MetricStore } from '@ai-sdlc/reference';
 import { type ExecuteOptions } from './execute.js';
+import { type PriorityInput } from './priority.js';
+import type { PriorityPolicy } from '@ai-sdlc/reference';
 export interface WatchOptions {
     /** Override the reconciler config (poll interval, concurrency, backoff). */
     reconcilerConfig?: Partial<ReconcilerConfig>;
@@ -21,10 +23,12 @@ export interface WatchOptions {
     qualityGates?: QualityGate[];
     /** Optional autonomy policies for autonomy reconciler evaluation. */
     autonomyPolicies?: AutonomyPolicy[];
+    /** Priority scoring policy configuration. */
+    priorityPolicy?: PriorityPolicy;
 }
 export interface WatchHandle {
-    /** Enqueue a pipeline resource for reconciliation. */
-    enqueue(pipeline: Pipeline, issueNumber: number): void;
+    /** Enqueue a pipeline resource for reconciliation. Optionally provide PriorityInput for scoring. */
+    enqueue(pipeline: Pipeline, issueId: string, priorityInput?: PriorityInput): void;
     /** Enqueue a quality gate resource for reconciliation. */
     enqueueGate(gate: QualityGate): void;
     /** Enqueue an autonomy policy resource for reconciliation. */

package/dist/watch.js

@@ -7,6 +7,7 @@
 import { ReconcilerLoop, createResourceCache, instrumentReconciler, } from '@ai-sdlc/reference';
 import { executePipeline } from './execute.js';
 import { createPipelineReconciler, createGateReconciler, createAutonomyReconciler, } from './reconcilers.js';
+import { computePriority } from './priority.js';
 /**
  * Start a reconciler watch loop that continuously processes pipeline resources.
  */
@@ -30,15 +31,15 @@ export function startWatch(options = {}) {
         switch (resource.kind) {
             case 'Pipeline': {
                 const pipeline = resource;
-                const issueNumber = issueMap.get(pipeline.metadata.name);
-                if (!issueNumber) {
+                const issueId = issueMap.get(pipeline.metadata.name);
+                if (!issueId) {
                     return {
                         type: 'error',
-                        error: new Error(`No issue number for pipeline ${pipeline.metadata.name}`),
+                        error: new Error(`No issue ID for pipeline ${pipeline.metadata.name}`),
                     };
                 }
                 try {
-                    await executePipeline(issueNumber, {
+                    await executePipeline(issueId, {
                         ...options.executeOptions,
                     });
                     const result = { type: 'success' };
@@ -68,9 +69,36 @@ export function startWatch(options = {}) {
     }
     const loop = new ReconcilerLoop(reconcileFn, options.reconcilerConfig);
     loop.start();
+    // Map to hold priority scores for pipelines
+    const priorityScores = new Map();
     return {
-        enqueue(pipeline, issueNumber) {
-            issueMap.set(pipeline.metadata.name, issueNumber);
+        enqueue(pipeline, issueId, priorityInput) {
+            issueMap.set(pipeline.metadata.name, issueId);
+            // Priority scoring when policy is enabled
+            if (options.priorityPolicy?.enabled && priorityInput) {
+                const config = options.priorityPolicy.dimensions?.humanCurveWeights
+                    ? { humanCurveWeights: options.priorityPolicy.dimensions.humanCurveWeights }
+                    : undefined;
+                const score = computePriority(priorityInput, config);
+                // Skip items below minimum score
+                if (options.priorityPolicy.minimumScore !== undefined &&
+                    score.composite < options.priorityPolicy.minimumScore) {
+                    return;
+                }
+                // Flag items below minimum confidence (still enqueue, but mark)
+                if (options.priorityPolicy.minimumConfidence !== undefined &&
+                    score.confidence < options.priorityPolicy.minimumConfidence) {
+                    // Store the score with a low-confidence flag for downstream consumers
+                    priorityScores.set(pipeline.metadata.name, score);
+                }
+                else {
+                    priorityScores.set(pipeline.metadata.name, score);
+                }
+                if (cache.shouldReconcile(pipeline)) {
+                    loop.enqueue(pipeline, score.composite);
+                }
+                return;
+            }
             if (cache.shouldReconcile(pipeline)) {
                 loop.enqueue(pipeline);
             }

package/dist/workflow-patterns/artifact-writer.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Artifact writer — generates files for approved pattern proposals.
+ * Never overwrites existing files.
+ */
+export interface WriteResult {
+    success: boolean;
+    filePath: string;
+    error?: string;
+}
+/**
+ * Write a proposal artifact to the filesystem.
+ * Creates parent directories if needed.
+ * Returns error if file already exists (never overwrites).
+ */
+export declare function writeArtifact(projectDir: string, relativePath: string, content: string): WriteResult;
+//# sourceMappingURL=artifact-writer.d.ts.map

package/dist/workflow-patterns/artifact-writer.js

@@ -0,0 +1,34 @@
+/**
+ * Artifact writer — generates files for approved pattern proposals.
+ * Never overwrites existing files.
+ */
+import { writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+/**
+ * Write a proposal artifact to the filesystem.
+ * Creates parent directories if needed.
+ * Returns error if file already exists (never overwrites).
+ */
+export function writeArtifact(projectDir, relativePath, content) {
+    const fullPath = join(projectDir, relativePath);
+    if (existsSync(fullPath)) {
+        return {
+            success: false,
+            filePath: fullPath,
+            error: `File already exists: ${relativePath}`,
+        };
+    }
+    try {
+        mkdirSync(dirname(fullPath), { recursive: true });
+        writeFileSync(fullPath, content, 'utf-8');
+        return { success: true, filePath: fullPath };
+    }
+    catch (err) {
+        return {
+            success: false,
+            filePath: fullPath,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+//# sourceMappingURL=artifact-writer.js.map

package/dist/workflow-patterns/classifiers.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Pattern type classifiers — refine detected patterns into
+ * specific automation types based on their structure.
+ */
+import type { DetectedPattern } from './types.js';
+/**
+ * Classify a detected pattern into a specific type and suggest an artifact.
+ */
+export declare function classifyPattern(pattern: DetectedPattern): DetectedPattern;
+//# sourceMappingURL=classifiers.d.ts.map

package/dist/workflow-patterns/classifiers.js

@@ -0,0 +1,72 @@
+/**
+ * Pattern type classifiers — refine detected patterns into
+ * specific automation types based on their structure.
+ */
+/**
+ * Classify a detected pattern into a specific type and suggest an artifact.
+ */
+export function classifyPattern(pattern) {
+    // Check classifiers in priority order
+    if (isCopyPasteCycle(pattern.steps)) {
+        return {
+            ...pattern,
+            patternType: 'copy-paste-cycle',
+            suggestedArtifactType: 'skill',
+        };
+    }
+    if (isPeriodicTask(pattern)) {
+        return {
+            ...pattern,
+            patternType: 'periodic-task',
+            suggestedArtifactType: 'workflow',
+        };
+    }
+    // Default: command sequence
+    return {
+        ...pattern,
+        patternType: 'command-sequence',
+        suggestedArtifactType: 'command',
+    };
+}
+/**
+ * Copy-paste cycle: Read from one file, then Write/Edit a different file type.
+ * Suggests the user is copying boilerplate or scaffolding from templates.
+ */
+function isCopyPasteCycle(steps) {
+    let hasRead = false;
+    let hasWriteAfterRead = false;
+    for (const step of steps) {
+        if (step.category === 'read') {
+            hasRead = true;
+        }
+        else if (hasRead && step.category === 'write') {
+            hasWriteAfterRead = true;
+        }
+    }
+    // Must have at least one read→write transition
+    if (!hasWriteAfterRead)
+        return false;
+    // The write should target a different file than the read
+    const readActions = steps.filter((s) => s.category === 'read').map((s) => s.action);
+    const writeActions = steps.filter((s) => s.category === 'write').map((s) => s.action);
+    // If reads and writes target different extensions, it's likely scaffolding
+    const readExts = new Set(readActions.map((a) => a.split(':').pop()));
+    const writeExts = new Set(writeActions.map((a) => a.split(':').pop()));
+    // Different file types or at least some diversity
+    const hasDistinctTargets = readExts.size > 0 && writeExts.size > 0 && ![...readExts].every((e) => writeExts.has(e));
+    return hasDistinctTargets || (readActions.length > 0 && writeActions.length > 1);
+}
+/**
+ * Periodic task: same pattern occurs with regular time spacing.
+ * Requires firstSeen and lastSeen spanning 7+ days.
+ */
+function isPeriodicTask(pattern) {
+    if (!pattern.firstSeen || !pattern.lastSeen)
+        return false;
+    const first = new Date(pattern.firstSeen).getTime();
+    const last = new Date(pattern.lastSeen).getTime();
+    const spanDays = (last - first) / (1000 * 60 * 60 * 24);
+    // Must span at least 7 days with regular occurrence
+    return spanDays >= 7 && pattern.sessionCount >= 3;
+}
+//# sourceMappingURL=classifiers.js.map

package/dist/workflow-patterns/detector.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Workflow pattern detector — mines frequent n-gram sequences
+ * from tool call histories across Claude Code sessions.
+ */
+import type { ToolSequenceEvent } from '../state/types.js';
+import type { CanonicalStep, NGram, DetectedPattern, DetectionOptions } from './types.js';
+/**
+ * Convert a raw tool event to a canonical step.
+ */
+export declare function canonicalizeStep(event: ToolSequenceEvent): CanonicalStep;
+/**
+ * Hash a sequence of canonical steps for grouping.
+ */
+export declare function hashSequence(steps: CanonicalStep[]): string;
+/**
+ * Group tool sequence events by session, ordered by timestamp.
+ */
+export declare function extractSessionSequences(events: ToolSequenceEvent[]): Map<string, CanonicalStep[]>;
+/**
+ * Generate all contiguous n-grams from a sequence.
+ */
+export declare function generateNGrams(sequence: CanonicalStep[], sessionId: string, minN: number, maxN: number): NGram[];
+/**
+ * Mine frequent patterns from tool sequence events.
+ */
+export declare function mineFrequentPatterns(events: ToolSequenceEvent[], opts?: Partial<DetectionOptions>): DetectedPattern[];
+//# sourceMappingURL=detector.d.ts.map

package/dist/workflow-patterns/detector.js

@@ -0,0 +1,186 @@
+/**
+ * Workflow pattern detector — mines frequent n-gram sequences
+ * from tool call histories across Claude Code sessions.
+ */
+import { createHash } from 'node:crypto';
+import { categorizeAction } from './telemetry-ingest.js';
+import { DEFAULT_DETECTION_OPTIONS } from './types.js';
+/**
+ * Convert a raw tool event to a canonical step.
+ */
+export function canonicalizeStep(event) {
+    return {
+        tool: event.toolName,
+        action: event.actionCanonical,
+        category: categorizeAction(event.toolName, event.actionCanonical),
+    };
+}
+/**
+ * Hash a sequence of canonical steps for grouping.
+ */
+export function hashSequence(steps) {
+    const key = steps.map((s) => `${s.tool}:${s.action}`).join('|');
+    return createHash('sha256').update(key).digest('hex').slice(0, 16);
+}
+/**
+ * Group tool sequence events by session, ordered by timestamp.
+ */
+export function extractSessionSequences(events) {
+    const sessions = new Map();
+    for (const event of events) {
+        const existing = sessions.get(event.sessionId) ?? [];
+        existing.push(event);
+        sessions.set(event.sessionId, existing);
+    }
+    const result = new Map();
+    for (const [sessionId, sessionEvents] of sessions) {
+        const sorted = sessionEvents.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+        result.set(sessionId, sorted.map(canonicalizeStep));
+    }
+    return result;
+}
+/**
+ * Generate all contiguous n-grams from a sequence.
+ */
+export function generateNGrams(sequence, sessionId, minN, maxN) {
+    const ngrams = [];
+    for (let n = minN; n <= Math.min(maxN, sequence.length); n++) {
+        for (let i = 0; i <= sequence.length - n; i++) {
+            const steps = sequence.slice(i, i + n);
+            ngrams.push({
+                steps,
+                hash: hashSequence(steps),
+                sessionId,
+            });
+        }
+    }
+    return ngrams;
+}
+/**
+ * Mine frequent patterns from tool sequence events.
+ */
+export function mineFrequentPatterns(events, opts) {
+    const options = { ...DEFAULT_DETECTION_OPTIONS, ...opts };
+    // Filter by project and time
+    let filtered = events;
+    if (options.projectFilter) {
+        filtered = filtered.filter((e) => e.projectPath === options.projectFilter);
+    }
+    if (options.since) {
+        const sinceDate = new Date(options.since).getTime();
+        filtered = filtered.filter((e) => new Date(e.timestamp).getTime() >= sinceDate);
+    }
+    if (filtered.length === 0)
+        return [];
+    // Group by session
+    const sessions = extractSessionSequences(filtered);
+    const totalSessions = sessions.size;
+    if (totalSessions < options.minSessionCount)
+        return [];
+    // Generate n-grams across all sessions
+    const aggregates = new Map();
+    for (const [sessionId, sequence] of sessions) {
+        const ngrams = generateNGrams(sequence, sessionId, options.minSequenceLength, options.maxSequenceLength);
+        // Deduplicate within a session (same hash counted once per session)
+        const seenInSession = new Set();
+        for (const ngram of ngrams) {
+            if (seenInSession.has(ngram.hash))
+                continue;
+            seenInSession.add(ngram.hash);
+            const existing = aggregates.get(ngram.hash);
+            if (existing) {
+                existing.frequency++;
+                existing.sessionIds.add(sessionId);
+            }
+            else {
+                aggregates.set(ngram.hash, {
+                    steps: ngram.steps,
+                    hash: ngram.hash,
+                    frequency: 1,
+                    sessionIds: new Set([sessionId]),
+                    timestamps: [],
+                });
+            }
+        }
+    }
+    // Filter by minimum frequency and session count
+    let patterns = [];
+    for (const agg of aggregates.values()) {
+        if (agg.frequency >= options.minFrequency && agg.sessionIds.size >= options.minSessionCount) {
+            patterns.push(agg);
+        }
+    }
+    // Compute confidence and find max frequency for normalization
+    const maxFrequency = Math.max(1, ...patterns.map((p) => p.frequency));
+    // Remove subsumed patterns (shorter patterns contained in longer ones with similar frequency)
+    patterns = removeSubsumedPatterns(patterns);
+    // Build detected patterns with confidence scoring
+    const detected = [];
+    for (const p of patterns) {
+        const confidence = Math.min(1.0, (p.sessionIds.size / totalSessions) * (p.frequency / maxFrequency));
+        if (confidence < options.minConfidence)
+            continue;
+        detected.push({
+            hash: p.hash,
+            steps: p.steps,
+            frequency: p.frequency,
+            sessionCount: p.sessionIds.size,
+            confidence,
+            patternType: 'command-sequence', // Default — classifiers refine this
+            suggestedArtifactType: 'command',
+            firstSeen: '', // Populated by caller from event timestamps
+            lastSeen: '',
+            exampleSessionIds: Array.from(p.sessionIds).slice(0, 5),
+        });
+    }
+    // Sort by confidence * length descending
+    detected.sort((a, b) => b.confidence * b.steps.length - a.confidence * a.steps.length);
+    return detected;
+}
+/**
+ * Remove patterns that are subsumed by longer patterns with similar frequency.
+ * A 3-gram is subsumed by a 5-gram if the 3-gram's steps appear contiguously
+ * in the 5-gram and the 5-gram has >= 70% of the 3-gram's frequency.
+ */
+function removeSubsumedPatterns(patterns) {
+    // Sort by length descending so longer patterns take priority
+    const sorted = [...patterns].sort((a, b) => b.steps.length - a.steps.length);
+    const kept = [];
+    const removed = new Set();
+    for (const pattern of sorted) {
+        if (removed.has(pattern.hash))
+            continue;
+        kept.push(pattern);
+        // Mark shorter patterns that are subsumed
+        for (const other of sorted) {
+            if (other.hash === pattern.hash || removed.has(other.hash))
+                continue;
+            if (other.steps.length >= pattern.steps.length)
+                continue;
+            if (isSubsequence(other.steps, pattern.steps) && pattern.frequency >= other.frequency * 0.7) {
+                removed.add(other.hash);
+            }
+        }
+    }
+    return kept;
+}
+/**
+ * Check if `short` appears as a contiguous subsequence in `long`.
+ */
+function isSubsequence(short, long) {
+    if (short.length > long.length)
+        return false;
+    for (let i = 0; i <= long.length - short.length; i++) {
+        let match = true;
+        for (let j = 0; j < short.length; j++) {
+            if (short[j].tool !== long[i + j].tool || short[j].action !== long[i + j].action) {
+                match = false;
+                break;
+            }
+        }
+        if (match)
+            return true;
+    }
+    return false;
+}
+//# sourceMappingURL=detector.js.map

package/dist/workflow-patterns/index.d.ts

@@ -0,0 +1,8 @@
+export { readToolSequenceJSONL, readSessionMetaFiles, sessionMetaToEvents, categorizeAction, } from './telemetry-ingest.js';
+export { canonicalizeStep, hashSequence, extractSessionSequences, generateNGrams, mineFrequentPatterns, } from './detector.js';
+export { classifyPattern } from './classifiers.js';
+export { generateProposal, generateName } from './proposal-generator.js';
+export { writeArtifact, type WriteResult } from './artifact-writer.js';
+export type { CanonicalStep, NGram, DetectedPattern, DetectionOptions, RawToolSequenceEntry, SessionMeta, } from './types.js';
+export { DEFAULT_DETECTION_OPTIONS } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/workflow-patterns/index.js

@@ -0,0 +1,7 @@
+export { readToolSequenceJSONL, readSessionMetaFiles, sessionMetaToEvents, categorizeAction, } from './telemetry-ingest.js';
+export { canonicalizeStep, hashSequence, extractSessionSequences, generateNGrams, mineFrequentPatterns, } from './detector.js';
+export { classifyPattern } from './classifiers.js';
+export { generateProposal, generateName } from './proposal-generator.js';
+export { writeArtifact } from './artifact-writer.js';
+export { DEFAULT_DETECTION_OPTIONS } from './types.js';
+//# sourceMappingURL=index.js.map

package/dist/workflow-patterns/proposal-generator.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Proposal generator — creates draft automation artifacts from detected patterns.
+ * Each pattern type maps to a specific artifact: command, skill, hook, or workflow.
+ */
+import type { DetectedPattern } from './types.js';
+import type { PatternProposal } from '../state/types.js';
+/**
+ * Generate an automation proposal from a detected pattern.
+ */
+export declare function generateProposal(pattern: DetectedPattern): Omit<PatternProposal, 'patternId'>;
+/**
+ * Generate a kebab-case name from the pattern's steps.
+ */
+export declare function generateName(pattern: DetectedPattern): string;
+//# sourceMappingURL=proposal-generator.d.ts.map