@rlynjb/aptkit-core 0.2.1 → 0.3.0

package/dist/src/index.d.ts

@@ -3,6 +3,7 @@ export * from '@aptkit/tools';
 export * from '@aptkit/context';
 export * from '@aptkit/prompts';
 export * from '@aptkit/evals';
+export * from '@aptkit/workflows';
 export * from '@aptkit/agent-recommendation';
 export { ANOMALY_MONITORING_CAPABILITY_ID, AnomalyMonitoringAgent, ECOMMERCE_ANOMALY_CATEGORIES, anomalyMonitoringToolPolicy, coverageReport, formatCategoryChecklist, runnableCategories, schemaCapabilities, tryParseAnomalies, validateAnomalies, } from '@aptkit/agent-anomaly-monitoring';
 export type { Anomaly as MonitoringAnomaly, AnomalyCategory as MonitoringAnomalyCategory, } from '@aptkit/agent-anomaly-monitoring';

package/dist/src/index.js

@@ -3,6 +3,7 @@ export * from '@aptkit/tools';
 export * from '@aptkit/context';
 export * from '@aptkit/prompts';
 export * from '@aptkit/evals';
+export * from '@aptkit/workflows';
 export * from '@aptkit/agent-recommendation';
 export { ANOMALY_MONITORING_CAPABILITY_ID, AnomalyMonitoringAgent, ECOMMERCE_ANOMALY_CATEGORIES, anomalyMonitoringToolPolicy, coverageReport, formatCategoryChecklist, runnableCategories, schemaCapabilities, tryParseAnomalies, validateAnomalies, } from '@aptkit/agent-anomaly-monitoring';
 export { DIAGNOSTIC_INVESTIGATION_CAPABILITY_ID, DiagnosticInvestigationAgent, diagnosticInvestigationToolPolicy, diagnosisConfidence, tryParseDiagnosis, validateDiagnosis, } from '@aptkit/agent-diagnostic-investigation';

package/node_modules/@aptkit/evals/dist/src/index.d.ts

@@ -1,3 +1,4 @@
 export * from './assertions.js';
 export * from './detection-scorer.js';
+export * from './rubric-judge.js';
 export * from './structural-diff.js';

package/node_modules/@aptkit/evals/dist/src/index.js

@@ -1,3 +1,4 @@
 export * from './assertions.js';
 export * from './detection-scorer.js';
+export * from './rubric-judge.js';
 export * from './structural-diff.js';

package/node_modules/@aptkit/evals/dist/src/rubric-judge.d.ts

@@ -0,0 +1,67 @@
+import { type CapabilityTraceSink, type JsonValidation, type ModelProvider, type StructuredGenerationResult } from '@aptkit/runtime';
+export type RubricScoreLevel = {
+    score: number;
+    description: string;
+};
+export type RubricDimension = {
+    id: string;
+    label: string;
+    description: string;
+    scale: readonly RubricScoreLevel[];
+};
+export type RubricVerdictRule = {
+    verdict: string;
+    description: string;
+};
+export type RubricCalibrationExample = {
+    input: string;
+    expected: string;
+};
+export type RubricDefinition = {
+    id: string;
+    title: string;
+    task: string;
+    dimensions: readonly RubricDimension[];
+    verdicts: readonly RubricVerdictRule[];
+    checks?: readonly string[];
+    calibrationExamples?: readonly RubricCalibrationExample[];
+};
+export type RubricDimensionScore = {
+    score: number;
+    reason: string;
+};
+export type RubricJudgment = {
+    dimensions: Record<string, RubricDimensionScore>;
+    checks?: Record<string, boolean>;
+    verdict: string;
+    fix: string;
+    reasoning?: string;
+};
+export type RubricJudgeInput = {
+    subject: string;
+    context?: Record<string, string>;
+};
+export type RubricJudgeOptions = {
+    model: ModelProvider;
+    rubric: RubricDefinition;
+    capabilityId?: string;
+    maxTokens?: number;
+    temperature?: number;
+    trace?: CapabilityTraceSink;
+};
+export type RubricJudgeRunOptions = {
+    signal?: AbortSignal;
+};
+export declare class RubricJudge {
+    private readonly model;
+    private readonly rubric;
+    private readonly capabilityId;
+    private readonly maxTokens;
+    private readonly temperature?;
+    private readonly trace?;
+    constructor(options: RubricJudgeOptions);
+    judge(input: RubricJudgeInput, options?: RubricJudgeRunOptions): Promise<StructuredGenerationResult<RubricJudgment>>;
+}
+export declare function buildRubricJudgeSystemPrompt(rubric: RubricDefinition): string;
+export declare function buildRubricJudgeUserPrompt(input: RubricJudgeInput): string;
+export declare function createRubricJudgmentValidator(rubric: RubricDefinition): (value: unknown) => JsonValidation<RubricJudgment>;

package/node_modules/@aptkit/evals/dist/src/rubric-judge.js

@@ -0,0 +1,154 @@
+import { generateStructured, } from '@aptkit/runtime';
+export class RubricJudge {
+    model;
+    rubric;
+    capabilityId;
+    maxTokens;
+    temperature;
+    trace;
+    constructor(options) {
+        this.model = options.model;
+        this.rubric = options.rubric;
+        this.capabilityId = options.capabilityId ?? 'rubric-judge';
+        this.maxTokens = options.maxTokens ?? 1200;
+        this.temperature = options.temperature;
+        this.trace = options.trace;
+    }
+    judge(input, options = {}) {
+        return generateStructured({
+            capabilityId: this.capabilityId,
+            model: this.model,
+            system: buildRubricJudgeSystemPrompt(this.rubric),
+            userPrompt: buildRubricJudgeUserPrompt(input),
+            validate: createRubricJudgmentValidator(this.rubric),
+            maxTokens: this.maxTokens,
+            temperature: this.temperature,
+            trace: this.trace,
+            signal: options.signal,
+        });
+    }
+}
+export function buildRubricJudgeSystemPrompt(rubric) {
+    const dimensions = rubric.dimensions
+        .map((dimension) => {
+        const scale = dimension.scale
+            .map((level) => `  ${level.score} = ${level.description}`)
+            .join('\n');
+        return `${dimension.id} ${dimension.label}: ${dimension.description}\n${scale}`;
+    })
+        .join('\n\n');
+    const verdicts = rubric.verdicts
+        .map((rule) => `- ${rule.verdict}: ${rule.description}`)
+        .join('\n');
+    const checks = rubric.checks?.length
+        ? `\nChecks to return as booleans:\n${rubric.checks.map((check) => `- ${check}`).join('\n')}\n`
+        : '';
+    const examples = rubric.calibrationExamples?.length
+        ? `\nCalibration examples. Use these only to anchor the scoring scale; do not repeat them.\n${rubric.calibrationExamples
+            .map((example) => `Input:\n${example.input}\nExpected:\n${example.expected}`)
+            .join('\n\n')}\n`
+        : '';
+    const dimensionShape = Object.fromEntries(rubric.dimensions.map((dimension) => [dimension.id, { score: 0, reason: '' }]));
+    const checkShape = Object.fromEntries((rubric.checks ?? []).map((check) => [check, true]));
+    const outputShape = {
+        dimensions: dimensionShape,
+        ...(rubric.checks?.length ? { checks: checkShape } : {}),
+        verdict: rubric.verdicts[0]?.verdict ?? 'pass',
+        fix: '',
+        reasoning: '',
+    };
+    return [
+        `You are a rubric judge for: ${rubric.title}.`,
+        rubric.task,
+        '',
+        'Score the subject against the rubric. Score meaning and evidence, not style preferences unless the rubric asks for style.',
+        'Never rewrite the subject. Return one highest-leverage fix, not a list.',
+        '',
+        'Rubric dimensions:',
+        dimensions,
+        '',
+        'Allowed verdicts:',
+        verdicts,
+        checks.trimEnd(),
+        examples.trimEnd(),
+        '',
+        'Output JSON only. No prose. No markdown fences. Use exactly this shape:',
+        JSON.stringify(outputShape),
+    ].filter(Boolean).join('\n');
+}
+export function buildRubricJudgeUserPrompt(input) {
+    const context = input.context && Object.keys(input.context).length > 0
+        ? `Context:\n${Object.entries(input.context).map(([key, value]) => `${key}: ${value}`).join('\n')}\n\n`
+        : '';
+    return `${context}Subject:\n${input.subject}`;
+}
+export function createRubricJudgmentValidator(rubric) {
+    const dimensionIds = new Set(rubric.dimensions.map((dimension) => dimension.id));
+    const verdicts = new Set(rubric.verdicts.map((rule) => rule.verdict));
+    const scoreRanges = new Map(rubric.dimensions.map((dimension) => [
+        dimension.id,
+        {
+            min: Math.min(...dimension.scale.map((level) => level.score)),
+            max: Math.max(...dimension.scale.map((level) => level.score)),
+        },
+    ]));
+    return (value) => {
+        if (!isRecord(value))
+            return { ok: false, error: 'judgment must be an object' };
+        if (!isRecord(value.dimensions))
+            return { ok: false, error: 'judgment.dimensions must be an object' };
+        const dimensions = {};
+        for (const id of dimensionIds) {
+            const score = value.dimensions[id];
+            if (!isRecord(score))
+                return { ok: false, error: `dimensions.${id} must be an object` };
+            if (typeof score.score !== 'number')
+                return { ok: false, error: `dimensions.${id}.score must be a number` };
+            if (typeof score.reason !== 'string')
+                return { ok: false, error: `dimensions.${id}.reason must be a string` };
+            const range = scoreRanges.get(id);
+            if (range && (score.score < range.min || score.score > range.max)) {
+                return { ok: false, error: `dimensions.${id}.score must be between ${range.min} and ${range.max}` };
+            }
+            dimensions[id] = { score: score.score, reason: score.reason.trim() };
+        }
+        if (typeof value.verdict !== 'string' || !verdicts.has(value.verdict)) {
+            return { ok: false, error: 'judgment.verdict is not allowed by the rubric' };
+        }
+        if (typeof value.fix !== 'string')
+            return { ok: false, error: 'judgment.fix must be a string' };
+        if (value.reasoning !== undefined && typeof value.reasoning !== 'string') {
+            return { ok: false, error: 'judgment.reasoning must be a string when present' };
+        }
+        const checks = validateChecks(value.checks, rubric.checks);
+        if (!checks.ok)
+            return checks;
+        return {
+            ok: true,
+            value: {
+                dimensions,
+                ...(checks.value ? { checks: checks.value } : {}),
+                verdict: value.verdict,
+                fix: value.fix.trim(),
+                ...(value.reasoning ? { reasoning: value.reasoning.trim() } : {}),
+            },
+        };
+    };
+}
+function validateChecks(value, expectedChecks) {
+    if (!expectedChecks?.length)
+        return { ok: true, value: undefined };
+    if (!isRecord(value))
+        return { ok: false, error: 'judgment.checks must be an object' };
+    const checks = {};
+    for (const check of expectedChecks) {
+        if (typeof value[check] !== 'boolean') {
+            return { ok: false, error: `checks.${check} must be a boolean` };
+        }
+        checks[check] = value[check];
+    }
+    return { ok: true, value: checks };
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}

package/node_modules/@aptkit/evals/package.json

@@ -21,6 +21,9 @@
     "build": "tsc -p tsconfig.json",
     "test": "npm run build && node --test dist/test/*.test.js"
   },
+  "dependencies": {
+    "@aptkit/runtime": "0.0.0"
+  },
   "devDependencies": {
     "@types/node": "^20.0.0"
   }

package/node_modules/@aptkit/runtime/dist/src/index.d.ts

@@ -3,4 +3,5 @@ export * from './json-output.js';
 export * from './model-provider.js';
 export * from './ndjson-stream.js';
 export * from './run-agent-loop.js';
+export * from './structured-generation.js';
 export * from './usage-ledger.js';

package/node_modules/@aptkit/runtime/dist/src/index.js

@@ -3,4 +3,5 @@ export * from './json-output.js';
 export * from './model-provider.js';
 export * from './ndjson-stream.js';
 export * from './run-agent-loop.js';
+export * from './structured-generation.js';
 export * from './usage-ledger.js';

package/node_modules/@aptkit/runtime/dist/src/structured-generation.d.ts

@@ -0,0 +1,43 @@
+import { type CapabilityTraceSink } from './events.js';
+import { type JsonValidator } from './json-output.js';
+import type { ModelMessage, ModelProvider } from './model-provider.js';
+export type StructuredGenerationAttempt = {
+    attempt: number;
+    rawText?: string;
+    error?: string;
+};
+export type StructuredGenerationSuccess<T> = {
+    ok: true;
+    value: T;
+    rawText: string;
+    attempts: StructuredGenerationAttempt[];
+};
+export type StructuredGenerationFailure = {
+    ok: false;
+    error: string;
+    attempts: StructuredGenerationAttempt[];
+};
+export type StructuredGenerationResult<T> = StructuredGenerationSuccess<T> | StructuredGenerationFailure;
+export type StructuredGenerationRetryOptions = {
+    maxAttempts?: number;
+    strictSuffix?: string;
+};
+export type GenerateStructuredOptions<T> = {
+    capabilityId: string;
+    model: ModelProvider;
+    validate: JsonValidator<T>;
+    system?: string;
+    messages?: ModelMessage[];
+    userPrompt?: string;
+    maxTokens?: number;
+    temperature?: number;
+    retry?: StructuredGenerationRetryOptions;
+    trace?: CapabilityTraceSink;
+    signal?: AbortSignal;
+};
+/**
+ * Runs a JSON-producing model prompt with bounded parse/validation retries.
+ * This is the provider-neutral version of Dryrun's on-device JSON pipeline:
+ * generate, extract JSON, validate, retry once with a strict JSON-only nudge.
+ */
+export declare function generateStructured<T>(options: GenerateStructuredOptions<T>): Promise<StructuredGenerationResult<T>>;

package/node_modules/@aptkit/runtime/dist/src/structured-generation.js

@@ -0,0 +1,109 @@
+import { timestamp } from './events.js';
+import { parseValidatedJson } from './json-output.js';
+const DEFAULT_STRICT_SUFFIX = '\n\nReturn ONLY valid JSON - no prose, no markdown fences.';
+/**
+ * Runs a JSON-producing model prompt with bounded parse/validation retries.
+ * This is the provider-neutral version of Dryrun's on-device JSON pipeline:
+ * generate, extract JSON, validate, retry once with a strict JSON-only nudge.
+ */
+export async function generateStructured(options) {
+    const maxAttempts = Math.max(1, options.retry?.maxAttempts ?? 2);
+    const strictSuffix = options.retry?.strictSuffix ?? DEFAULT_STRICT_SUFFIX;
+    const baseMessages = normalizeMessages(options);
+    const attempts = [];
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        options.signal?.throwIfAborted();
+        const messages = attempt === 1 ? baseMessages : appendStrictSuffix(baseMessages, strictSuffix);
+        let response;
+        try {
+            response = await options.model.complete({
+                system: options.system,
+                messages,
+                maxTokens: options.maxTokens,
+                temperature: options.temperature,
+                signal: options.signal,
+            });
+        }
+        catch (error) {
+            if (isAbortError(error) || options.signal?.aborted)
+                throw error;
+            const message = error instanceof Error ? error.message : String(error);
+            attempts.push({ attempt, error: message });
+            emitWarning(options, `structured generation model call failed on attempt ${attempt}: ${message}`);
+            return { ok: false, error: message, attempts };
+        }
+        emitUsage(options, response);
+        const rawText = textFromResponse(response);
+        const parsed = parseValidatedJson(rawText, options.validate);
+        if (parsed.ok) {
+            attempts.push({ attempt, rawText });
+            return { ok: true, value: parsed.value, rawText, attempts };
+        }
+        attempts.push({ attempt, rawText, error: parsed.error });
+        if (attempt < maxAttempts) {
+            emitWarning(options, `structured generation validation failed on attempt ${attempt}: ${parsed.error}`);
+        }
+    }
+    const error = attempts[attempts.length - 1]?.error ?? 'structured generation failed';
+    emitError(options, `structured generation failed after ${maxAttempts} attempt${maxAttempts === 1 ? '' : 's'}: ${error}`);
+    return { ok: false, error, attempts };
+}
+function normalizeMessages(options) {
+    if (options.messages?.length)
+        return [...options.messages];
+    if (options.userPrompt !== undefined)
+        return [{ role: 'user', content: options.userPrompt }];
+    throw new Error('generateStructured requires messages or userPrompt');
+}
+function appendStrictSuffix(messages, strictSuffix) {
+    const next = [...messages];
+    for (let index = next.length - 1; index >= 0; index -= 1) {
+        const message = next[index];
+        if (message.role === 'user' && typeof message.content === 'string') {
+            next[index] = { ...message, content: `${message.content}${strictSuffix}` };
+            return next;
+        }
+    }
+    next.push({ role: 'user', content: strictSuffix.trim() });
+    return next;
+}
+function textFromResponse(response) {
+    return response.content
+        .filter((block) => block.type === 'text')
+        .map((block) => block.text)
+        .join('');
+}
+function emitUsage(options, response) {
+    if (!response.usage)
+        return;
+    options.trace?.emit({
+        type: 'model_usage',
+        capabilityId: options.capabilityId,
+        provider: options.model.id,
+        model: response.model ?? options.model.defaultModel ?? 'unknown',
+        inputTokens: response.usage.inputTokens,
+        outputTokens: response.usage.outputTokens,
+        estimated: response.usage.estimated,
+        timestamp: timestamp(),
+    });
+}
+function emitWarning(options, message) {
+    options.trace?.emit({
+        type: 'warning',
+        capabilityId: options.capabilityId,
+        message,
+        timestamp: timestamp(),
+    });
+}
+function emitError(options, message) {
+    options.trace?.emit({
+        type: 'error',
+        capabilityId: options.capabilityId,
+        message,
+        timestamp: timestamp(),
+    });
+}
+function isAbortError(error) {
+    return error instanceof DOMException && error.name === 'AbortError'
+        || error instanceof Error && error.name === 'AbortError';
+}

package/node_modules/@aptkit/workflows/README.md

@@ -0,0 +1,6 @@
+# @aptkit/workflows
+
+Reusable workflow orchestration helpers for AptKit capabilities.
+
+This package owns deterministic workflow mechanics only. Host apps provide
+storage, domain prompts, model providers, and output card shapes.

package/node_modules/@aptkit/workflows/dist/src/content-generation-workflow.d.ts

@@ -0,0 +1,58 @@
+import { type CapabilityTraceSink } from '@aptkit/runtime';
+import { type MarkdownSection } from './markdown-sections.js';
+export type ContentAngle = {
+    id: string;
+    label: string;
+};
+export type ExistingContentVariant = {
+    sourceHash: string;
+    variantIndex: number;
+};
+export type ContentVariantPlan = {
+    sourceHash: string;
+    variantIndex: number;
+    sectionIndex: number;
+    totalSections: number;
+    section: MarkdownSection;
+    angle: ContentAngle;
+};
+export type GeneratedContentVariant<T> = ContentVariantPlan & {
+    item: T;
+};
+export type ContentGenerator<T> = (plan: ContentVariantPlan, options?: {
+    signal?: AbortSignal;
+    trace?: CapabilityTraceSink;
+}) => Promise<T | null>;
+export type EnsureGeneratedContentOptions<TExisting extends ExistingContentVariant, TGenerated> = {
+    capabilityId?: string;
+    sourceMarkdown: string;
+    sourceHash: string;
+    existing: readonly TExisting[];
+    targetCount?: number;
+    angles: readonly ContentAngle[];
+    maxSkips?: number;
+    generator: ContentGenerator<TGenerated>;
+    trace?: CapabilityTraceSink;
+    signal?: AbortSignal;
+};
+export type EnsureGeneratedContentResult<TExisting extends ExistingContentVariant, TGenerated> = {
+    freshExisting: TExisting[];
+    staleExisting: TExisting[];
+    generated: GeneratedContentVariant<TGenerated>[];
+    items: Array<TExisting | GeneratedContentVariant<TGenerated>>;
+    attempted: ContentVariantPlan[];
+    skipped: ContentVariantPlan[];
+};
+/**
+ * Ensures a source document has enough generated variants for the current hash.
+ *
+ * The host owns persistence. This helper returns fresh existing variants,
+ * stale variants to invalidate, and newly generated variants to save.
+ */
+export declare function ensureGeneratedContent<TExisting extends ExistingContentVariant, TGenerated>(options: EnsureGeneratedContentOptions<TExisting, TGenerated>): Promise<EnsureGeneratedContentResult<TExisting, TGenerated>>;
+export declare function planContentVariant(options: {
+    sourceHash: string;
+    variantIndex: number;
+    sections: readonly MarkdownSection[];
+    angles: readonly ContentAngle[];
+}): ContentVariantPlan;

package/node_modules/@aptkit/workflows/dist/src/content-generation-workflow.js

@@ -0,0 +1,93 @@
+import { timestamp } from '@aptkit/runtime';
+import { splitMarkdownSections } from './markdown-sections.js';
+const DEFAULT_TARGET_COUNT = 4;
+const DEFAULT_MAX_SKIPS = 3;
+/**
+ * Ensures a source document has enough generated variants for the current hash.
+ *
+ * The host owns persistence. This helper returns fresh existing variants,
+ * stale variants to invalidate, and newly generated variants to save.
+ */
+export async function ensureGeneratedContent(options) {
+    options.signal?.throwIfAborted();
+    if (options.angles.length === 0)
+        throw new Error('ensureGeneratedContent requires at least one angle');
+    const capabilityId = options.capabilityId ?? 'content-generation-workflow';
+    const targetCount = Math.max(0, options.targetCount ?? DEFAULT_TARGET_COUNT);
+    const maxSkips = Math.max(0, options.maxSkips ?? DEFAULT_MAX_SKIPS);
+    const sections = splitMarkdownSections(options.sourceMarkdown);
+    const freshExisting = options.existing
+        .filter((item) => item.sourceHash === options.sourceHash)
+        .sort((a, b) => a.variantIndex - b.variantIndex);
+    const staleExisting = options.existing
+        .filter((item) => item.sourceHash !== options.sourceHash)
+        .sort((a, b) => a.variantIndex - b.variantIndex);
+    if (targetCount === 0 || sections.length === 0 || freshExisting.length >= targetCount) {
+        return {
+            freshExisting,
+            staleExisting,
+            generated: [],
+            items: freshExisting,
+            attempted: [],
+            skipped: [],
+        };
+    }
+    const needed = targetCount - freshExisting.length;
+    const baseIndex = (freshExisting.at(-1)?.variantIndex ?? -1) + 1;
+    const lastIndex = baseIndex + needed + maxSkips;
+    const generated = [];
+    const attempted = [];
+    const skipped = [];
+    for (let variantIndex = baseIndex; generated.length < needed && variantIndex < lastIndex; variantIndex += 1) {
+        options.signal?.throwIfAborted();
+        const plan = planContentVariant({
+            sourceHash: options.sourceHash,
+            variantIndex,
+            sections,
+            angles: options.angles,
+        });
+        attempted.push(plan);
+        options.trace?.emit({
+            type: 'step',
+            capabilityId,
+            role: 'workflow',
+            content: `generating ${plan.angle.label} for section ${plan.sectionIndex + 1} of ${plan.totalSections}`,
+            timestamp: timestamp(),
+        });
+        const item = await options.generator(plan, { signal: options.signal, trace: options.trace });
+        if (item === null) {
+            skipped.push(plan);
+            options.trace?.emit({
+                type: 'warning',
+                capabilityId,
+                message: `content variant ${variantIndex} produced no usable output; trying next variant`,
+                timestamp: timestamp(),
+            });
+            continue;
+        }
+        generated.push({ ...plan, item });
+    }
+    return {
+        freshExisting,
+        staleExisting,
+        generated,
+        items: [...freshExisting, ...generated],
+        attempted,
+        skipped,
+    };
+}
+export function planContentVariant(options) {
+    if (options.sections.length === 0)
+        throw new Error('planContentVariant requires at least one section');
+    if (options.angles.length === 0)
+        throw new Error('planContentVariant requires at least one angle');
+    const sectionIndex = options.variantIndex % options.sections.length;
+    return {
+        sourceHash: options.sourceHash,
+        variantIndex: options.variantIndex,
+        sectionIndex,
+        totalSections: options.sections.length,
+        section: options.sections[sectionIndex],
+        angle: options.angles[options.variantIndex % options.angles.length],
+    };
+}

package/node_modules/@aptkit/workflows/dist/src/index.d.ts

@@ -0,0 +1,2 @@
+export * from './content-generation-workflow.js';
+export * from './markdown-sections.js';

package/node_modules/@aptkit/workflows/dist/src/index.js

@@ -0,0 +1,2 @@
+export * from './content-generation-workflow.js';
+export * from './markdown-sections.js';

package/node_modules/@aptkit/workflows/dist/src/markdown-sections.d.ts

@@ -0,0 +1,9 @@
+export type MarkdownSection = {
+    heading?: string;
+    content: string;
+};
+/**
+ * Splits markdown into ordered sections by h2 (`##`) headings. H3+ headings
+ * stay inside the current section, matching Dryrun's source-document workflow.
+ */
+export declare function splitMarkdownSections(markdown: string): MarkdownSection[];

package/node_modules/@aptkit/workflows/dist/src/markdown-sections.js

@@ -0,0 +1,32 @@
+/**
+ * Splits markdown into ordered sections by h2 (`##`) headings. H3+ headings
+ * stay inside the current section, matching Dryrun's source-document workflow.
+ */
+export function splitMarkdownSections(markdown) {
+    if (markdown.trim().length === 0)
+        return [];
+    const sections = [];
+    let heading;
+    let body = [];
+    function flush() {
+        const content = body.join('\n').trim();
+        if (content.length > 0 || heading !== undefined) {
+            sections.push(heading === undefined ? { content } : { heading, content });
+        }
+        body = [];
+    }
+    for (const line of markdown.split(/\r?\n/)) {
+        const trimmed = line.trimStart();
+        if (trimmed.startsWith('## ') && !trimmed.startsWith('### ')) {
+            flush();
+            heading = trimmed.slice(3).trim();
+        }
+        else {
+            body.push(line);
+        }
+    }
+    flush();
+    if (sections.length === 0)
+        return [{ content: markdown.trim() }];
+    return sections;
+}

package/node_modules/@aptkit/workflows/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@aptkit/workflows",
+  "version": "0.0.0",
+  "type": "module",
+  "main": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
+  "files": [
+    "README.md",
+    "dist/src"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "npm run build && node --test dist/test/*.test.js"
+  },
+  "dependencies": {
+    "@aptkit/runtime": "0.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0"
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rlynjb/aptkit-core",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "type": "module",
   "description": "Standalone AptKit core bundle for extracted agent capabilities.",
   "main": "./dist/src/index.js",
@@ -25,7 +25,7 @@
     }
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "tsc -b tsconfig.json",
     "test": "npm run build && node --test dist/test/*.test.js"
   },
   "dependencies": {
@@ -37,7 +37,8 @@
     "@aptkit/evals": "0.0.0",
     "@aptkit/prompts": "0.0.0",
     "@aptkit/runtime": "0.0.0",
-    "@aptkit/tools": "0.0.0"
+    "@aptkit/tools": "0.0.0",
+    "@aptkit/workflows": "0.0.0"
   },
   "bundledDependencies": [
     "@aptkit/agent-anomaly-monitoring",
@@ -48,6 +49,7 @@
     "@aptkit/evals",
     "@aptkit/prompts",
     "@aptkit/runtime",
-    "@aptkit/tools"
+    "@aptkit/tools",
+    "@aptkit/workflows"
   ]
 }