@ai-sdlc/orchestrator 0.5.0 → 0.9.0

package/dist/state/types.d.ts

@@ -113,11 +113,16 @@ export interface CostLedgerEntry {
     runId: string;
     agentName: string;
     pipelineType: string;
+    /** Resolved physical model ID (e.g., 'claude-sonnet-4-6'). RFC-0010 §11.4. */
     model?: string;
+    /** Original alias used in pipeline YAML before resolution (e.g., 'sonnet'). RFC-0010 §11.4. */
+    modelAlias?: string;
     inputTokens?: number;
     outputTokens?: number;
     totalTokens?: number;
     costUsd?: number;
+    /** Informational shadow cost (what this work would have cost on pay-per-token); does NOT decrement costBudget. RFC-0010 §14.10. */
+    shadowCostUsd?: number;
     issueId?: string;
     issueNumber?: number;
     prNumber?: number;
@@ -204,4 +209,173 @@ export interface AuditEntryRecord {
     signature?: string;
     createdAt?: string;
 }
+export interface ToolSequenceEvent {
+    id?: number;
+    sessionId: string;
+    toolName: string;
+    actionCanonical: string;
+    projectPath?: string;
+    timestamp: string;
+    ingestedAt?: string;
+}
+export interface WorkflowPattern {
+    id?: number;
+    patternHash: string;
+    patternType: string;
+    sequenceJson: string;
+    frequency: number;
+    sessionCount: number;
+    confidence: number;
+    firstSeen?: string;
+    lastSeen?: string;
+    status: string;
+    detectedAt?: string;
+}
+export interface PatternProposal {
+    id?: number;
+    patternId: number;
+    proposalType: string;
+    artifactType: string;
+    artifactPath?: string;
+    draftContent: string;
+    confidence: number;
+    status: string;
+    reviewedAt?: string;
+    reviewerReason?: string;
+    createdAt?: string;
+}
+export interface DesignTokenEventRecord {
+    id?: number;
+    bindingName: string;
+    eventType: 'changed' | 'deleted' | 'breaking';
+    tokensAffected?: number;
+    diffJson?: string;
+    actor?: string;
+    pipelineRunId?: string;
+    designReviewDecision?: string;
+    createdAt?: string;
+}
+export interface DesignReviewEventRecord {
+    id?: number;
+    bindingName: string;
+    prNumber?: number;
+    componentName?: string;
+    reviewer: string;
+    decision: 'approved' | 'rejected' | 'approved-with-comments';
+    categoriesJson?: string;
+    actionableNotes?: string;
+    createdAt?: string;
+}
+export interface TokenComplianceRecord {
+    id?: number;
+    bindingName: string;
+    coveragePercent: number;
+    violationsCount: number;
+    scannedAt?: string;
+}
+export interface VisualRegressionResultRecord {
+    id?: number;
+    bindingName: string;
+    storyName: string;
+    viewport?: number;
+    diffPercentage: number;
+    approved?: boolean;
+    approver?: string;
+    baselineUrl?: string;
+    currentUrl?: string;
+    createdAt?: string;
+}
+export interface UsabilitySimulationResultRecord {
+    id?: number;
+    bindingName: string;
+    storyName: string;
+    personaId?: string;
+    taskId?: string;
+    completed?: boolean;
+    actionsTaken?: number;
+    expectedActions?: number;
+    efficiency?: number;
+    findingsJson?: string;
+    createdAt?: string;
+}
+export interface DidCompiledArtifactRecord {
+    id?: number;
+    didName: string;
+    namespace?: string;
+    sourceHash: string;
+    scopeListsJson?: string;
+    constraintRulesJson?: string;
+    antiPatternListsJson?: string;
+    measurableSignalsJson?: string;
+    bm25CorpusBlob?: Buffer;
+    principleCorporaBlob?: Buffer;
+    compiledAt?: string;
+}
+export type SaDimension = 'SA-1' | 'SA-2';
+export type SaPhase = '1' | '2a' | '2b' | '2c' | '3';
+export interface DidScoringEventRecord {
+    id?: number;
+    didName: string;
+    issueNumber: number;
+    saDimension: SaDimension;
+    phase: SaPhase;
+    layer1ResultJson?: string;
+    layer2ResultJson?: string;
+    layer3ResultJson?: string;
+    compositeScore?: number;
+    phaseWeightsJson?: string;
+    createdAt?: string;
+}
+export type FeedbackSignal = 'accept' | 'dismiss' | 'escalate' | 'override';
+export interface DidFeedbackEventRecord {
+    id?: number;
+    didName: string;
+    issueNumber: number;
+    dimension: SaDimension;
+    signal: FeedbackSignal;
+    principal?: string;
+    category?: string;
+    structuralScore?: number;
+    llmScore?: number;
+    compositeScore?: number;
+    notes?: string;
+    createdAt?: string;
+}
+export interface DesignChangeEventRecord {
+    id?: number;
+    didName: string;
+    changeId: string;
+    changeType: string;
+    status: string;
+    payloadJson: string;
+    emittedAt?: string;
+}
+export interface CodeAreaMetricsRecord {
+    id?: number;
+    codeArea: string;
+    defectDensity?: number;
+    churnRate?: number;
+    prRejectionRate?: number;
+    codeAcceptanceRate?: number;
+    hasFrontendComponents?: boolean;
+    designMetricsJson?: string;
+    dataPointCount?: number;
+    windowStart?: string;
+    windowEnd?: string;
+    computedAt?: string;
+}
+export interface DesignLookaheadNotificationRecord {
+    id?: number;
+    issueNumber: number;
+    firstNotifiedAt?: string;
+    lastNotifiedAt?: string;
+    pillarBreakdownJson?: string;
+}
+export interface SaPhaseWeightsRecord {
+    id?: number;
+    dimension: SaDimension;
+    wStructural: number;
+    wLlm: number;
+    calibratedAt?: string;
+}
 //# sourceMappingURL=types.d.ts.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, PriorityPolicy, PriorityDimensionConfig, PriorityDimensionsConfig, PriorityCalibrationConfig, PriorityAdaptersConfig, 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, DesignToolAuthority, TokenFormat, TokenVersionPolicy, ConflictResolution, SyncDirection, OnTimeout, TokenPlatform, DesignReviewScope, DesignReviewAlwaysOn, DesignReviewCondition, AuthorityBlock, ChangeApproval, Stewardship, TokenSource, TokenSyncConfig, TokenConfig, CatalogSource, CatalogDiscovery, CatalogConfig, VisualRegressionProviderConfig, VisualRegressionConfig, HardcodedRule, CoverageThreshold, ComplianceConfig, DesignReviewTriggerCondition, DesignReviewTriggerConditions, DesignReviewConfig, DesignSystemBindingSpec, TokenSyncStatus, CatalogHealthStatus, TokenComplianceStatus, DesignReviewStatus, DesignSystemBindingStatus, DesignSystemBinding, AnyResource, ResourceKind, PriorityPolicy, PriorityDimensionConfig, PriorityDimensionsConfig, PriorityCalibrationConfig, PriorityAdaptersConfig, DesignSystemPermissions, DesignReviewRequirement, StageConstraints, ContextStrategy, ContextStrategyOverride, ComponentCreationPolicy, AgentDesignSystemConfig, DesignTokenComplianceRule, VisualRegressionRule, StoryCompletenessRule, DesignReviewDecision, DesignReviewFeedbackCategory, DesignReviewRating, DesignReviewFeedback, DesignReviewGateRule, 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/validate-agent-output.js

@@ -4,6 +4,7 @@
  * Pure validation module with no side effects (fully testable).
  */
 import { execFile } from 'node:child_process';
+import { cleanGitEnv } from './runtime/git-env.js';
 /**
  * Match a file path against a blocked-path pattern.
  * Supports simple glob suffixes: `foo/**` matches anything under `foo/`.
@@ -52,8 +53,10 @@ export async function validateAgentOutput(ctx) {
     }
     // 3. Max lines per PR
     if (ctx.guardrails.maxLinesPerPR !== undefined) {
+        // cleanGitEnv() prevents leaked GIT_DIR from binding this call to a
+        // parent process's git repo (AISDLC-72).
         const stdout = await new Promise((resolve, reject) => {
-            execFile('git', ['diff', '--stat', 'HEAD~1'], { cwd: ctx.workDir }, (err, out) => {
+            execFile('git', ['diff', '--stat', 'HEAD~1'], { cwd: ctx.workDir, env: cleanGitEnv() }, (err, out) => {
                 if (err)
                     reject(err);
                 else

package/dist/watch.js

@@ -41,6 +41,12 @@ export function startWatch(options = {}) {
                 try {
                     await executePipeline(issueId, {
                         ...options.executeOptions,
+                        // Pass the dispatcher-selected pipeline so executePipeline doesn't
+                        // re-load from disk and pick the wrong one in multi-pipeline configs
+                        // (RFC-0010 dual workflow). Without this, an enqueued backlog
+                        // pipeline silently downgrades to pipeline.yaml's branching/PR
+                        // templates.
+                        pipelineOverride: pipeline,
                     });
                     const result = { type: 'success' };
                     options.onReconcile?.(pipeline.metadata.name, result);

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