cloving 1.2.0 → 1.4.0

package/dist/src/chats/structure.js

@@ -1,216 +0,0 @@
-function reference(occurrence) {
-    return { recordIndex: occurrence.recordIndex, sourceId: occurrence.sourceId };
-}
-function rawJsonApi(value) {
-    return "isRawJSON" in value && typeof value.isRawJSON === "function";
-}
-function canonical(value) {
-    if (rawJsonApi(JSON) && JSON.isRawJSON(value))
-        return JSON.stringify(value);
-    if (Array.isArray(value))
-        return `[${value.map(canonical).join(",")}]`;
-    if (value === null || typeof value !== "object")
-        return JSON.stringify(value);
-    return `{${Object.entries(value)
-        .sort(([left], [right]) => (left < right ? -1 : Number(left > right)))
-        .map(([key, member]) => `${JSON.stringify(key)}:${canonical(member)}`)
-        .join(",")}}`;
-}
-function occurrence(record, context) {
-    const { recordIndex, identities } = context;
-    const metadata = record.schemaVersion === 2
-        ? {
-            uuid: record.uuid,
-            isSidechain: record.isSidechain,
-            ...(Object.hasOwn(record, "parentUuid")
-                ? { parentUuid: record.parentUuid }
-                : {}),
-        }
-        : { uuid: null, isSidechain: null };
-    const current = {
-        ...reference({ recordIndex, sourceId: record.sourceId }),
-        sessionId: record.sessionId,
-        ...metadata,
-    };
-    if (current.uuid === null)
-        return current;
-    const variants = identities.get(current.uuid) ?? new Map();
-    identities.set(current.uuid, variants);
-    const content = canonical([record.role, record.text, record.blocks]);
-    const matches = variants.get(content) ?? [];
-    variants.set(content, matches);
-    const first = matches[0];
-    matches.push(reference(current));
-    return first === undefined ? current : { ...current, copyOf: { ...first } };
-}
-function groupNodes(occurrences) {
-    const groups = new Map();
-    for (const item of occurrences) {
-        const key = item.uuid ?? item.recordIndex;
-        const group = groups.get(key) ?? [];
-        groups.set(key, group);
-        group.push(item);
-    }
-    return [...groups.values()];
-}
-function parentLinks(group, known) {
-    const parents = new Map();
-    for (const item of group) {
-        if (item.parentUuid === undefined)
-            continue;
-        const references = parents.get(item.parentUuid) ?? [];
-        parents.set(item.parentUuid, references);
-        references.push(reference(item));
-    }
-    const childUuid = group[0]?.uuid ?? null;
-    return [...parents].map(([parentUuid, occurrences]) => {
-        let status = "resolved";
-        if (parentUuid === null)
-            status = "root";
-        if (parentUuid !== null && !known.has(parentUuid))
-            status = "missing";
-        if (childUuid === null || parents.size > 1)
-            status = "ambiguous";
-        return { childUuid, parentUuid, occurrences, status };
-    });
-}
-function forkPoints(links) {
-    const children = new Map();
-    for (const link of links) {
-        if (link.status === "ambiguous" ||
-            link.parentUuid === null ||
-            link.childUuid === null)
-            continue;
-        const ids = children.get(link.parentUuid) ?? new Set();
-        children.set(link.parentUuid, ids);
-        ids.add(link.childUuid);
-    }
-    return [...children]
-        .filter(([, ids]) => ids.size > 1)
-        .map(([parentUuid, ids]) => ({ parentUuid, childUuids: [...ids] }));
-}
-function finishFrom(graph, state) {
-    const { visited, order } = state;
-    const stack = [{ id: state.start, expanded: false }];
-    while (stack.length > 0) {
-        const item = stack.pop();
-        if (item === undefined)
-            break;
-        if (item.expanded) {
-            order.push(item.id);
-            continue;
-        }
-        if (visited.has(item.id))
-            continue;
-        visited.add(item.id);
-        stack.push({ id: item.id, expanded: true });
-        for (const id of graph.get(item.id) ?? [])
-            stack.push({ id, expanded: false });
-    }
-}
-function finishOrder(graph) {
-    const visited = new Set();
-    const order = [];
-    for (const start of graph.keys())
-        finishFrom(graph, { start, visited, order });
-    return order;
-}
-function observedGraph(known, links) {
-    const graph = new Map([...known].map((id) => [id, []]));
-    const reverse = new Map([...known].map((id) => [id, []]));
-    for (const link of links) {
-        if (link.childUuid === null ||
-            link.parentUuid === null ||
-            !known.has(link.parentUuid))
-            continue;
-        graph.get(link.childUuid)?.push(link.parentUuid);
-        reverse.get(link.parentUuid)?.push(link.childUuid);
-    }
-    return { graph, reverse };
-}
-function componentFrom(graph, state) {
-    const component = [];
-    const stack = [state.start];
-    while (stack.length > 0) {
-        const id = stack.pop();
-        if (id === undefined || state.visited.has(id))
-            continue;
-        state.visited.add(id);
-        component.push(id);
-        for (const parent of graph.get(id) ?? [])
-            stack.push(parent);
-    }
-    return component;
-}
-function cycleGroups(known, links) {
-    const { graph, reverse } = observedGraph(known, links);
-    const rank = new Map([...known].map((id, index) => [id, index]));
-    const visited = new Set();
-    const cycles = [];
-    for (const start of finishOrder(graph).reverse()) {
-        if (visited.has(start))
-            continue;
-        const component = componentFrom(reverse, { start, visited });
-        if (component.length > 1 || graph.get(start)?.includes(start))
-            cycles.push(component.sort((left, right) => Number(rank.get(left)) - Number(rank.get(right))));
-    }
-    return cycles.sort((left, right) => Number(rank.get(String(left[0]))) - Number(rank.get(String(right[0]))));
-}
-function sessionStructure(sessionId, occurrences) {
-    const groups = groupNodes(occurrences);
-    const known = new Set(occurrences.flatMap((item) => (item.uuid === null ? [] : [item.uuid])));
-    const links = groups.flatMap((group) => parentLinks(group, known));
-    return {
-        sessionId,
-        nodes: groups.map((group) => ({
-            uuid: group[0]?.uuid ?? null,
-            occurrences: group.map(reference),
-        })),
-        links,
-        forkPoints: forkPoints(links),
-        unknownParents: occurrences
-            .filter((item) => !Object.hasOwn(item, "parentUuid"))
-            .map(reference),
-        missingParentTargets: [
-            ...new Set(links.flatMap((link) => link.parentUuid !== null && !known.has(link.parentUuid)
-                ? [link.parentUuid]
-                : [])),
-        ],
-        cycles: cycleGroups(known, links),
-    };
-}
-export function structureImport(records) {
-    const identities = new Map();
-    const occurrences = records.map((record, index) => occurrence(record, { recordIndex: index, identities }));
-    const grouped = new Map();
-    for (const item of occurrences) {
-        if (item.sessionId === null || item.sessionId === "")
-            continue;
-        const group = grouped.get(item.sessionId) ?? [];
-        grouped.set(item.sessionId, group);
-        group.push(item);
-    }
-    const sessions = [...grouped].map(([id, group]) => sessionStructure(id, group));
-    const conflictGroups = [...identities]
-        .filter(([, variants]) => variants.size > 1)
-        .map(([uuid, variants]) => ({ uuid, variants: [...variants.values()] }));
-    return {
-        historyCompleteness: "unknown",
-        counts: {
-            records: records.length,
-            knownSessions: sessions.length,
-            forks: sessions.reduce((sum, session) => sum + session.forkPoints.length, 0),
-            copies: occurrences.filter((item) => item.copyOf !== undefined).length,
-            conflictGroups: conflictGroups.length,
-            unknownIdentities: occurrences.filter((item) => item.uuid === null)
-                .length,
-            missingParentTargets: sessions.reduce((sum, session) => sum + session.missingParentTargets.length, 0),
-        },
-        occurrences,
-        conflictGroups,
-        sessions,
-        unknownSessions: occurrences
-            .filter((item) => item.sessionId === null || item.sessionId === "")
-            .map(reference),
-    };
-}

package/dist/src/chats/workflow-generation-projection.d.ts

@@ -1,8 +0,0 @@
-import type { AnalysisProcess, AnalysisResult, AnalysisStage } from "./analysis-contract.ts";
-import type { InstalledWorkflowExports } from "../workflow-candidate.ts";
-export interface WorkflowGenerationAvailability {
-    readonly exports: InstalledWorkflowExports;
-    readonly methods: Readonly<Record<string, readonly string[]>>;
-}
-export declare function executionStages(process: AnalysisProcess): readonly AnalysisStage[];
-export declare function generationGaps(analysis: AnalysisResult, availability: WorkflowGenerationAvailability): readonly string[];

package/dist/src/chats/workflow-generation-projection.js

@@ -1,75 +0,0 @@
-const generationExports = {
-    "cloving/workflows": ["CycleOutcome", "ProtectedResult"],
-    "cloving/workflows/steps/protected-effect": ["protectedEffect"],
-    "cloving/workflows/steps/decision-gate": ["decisionGate"],
-};
-export function executionStages(process) {
-    return process.stages.filter((stage) => ["explicit-human-instruction", "observed-repetition"].includes(stage.kind) && ["work", "routine-repair"].includes(stage.activity));
-}
-function supportedBranch(process) {
-    const [review, repair] = executionStages(process);
-    const branch = process.branches[0];
-    return (process.branches.length === 1 &&
-        branch !== undefined &&
-        branch.sourceStageId === review?.id &&
-        branch.targetStageId === repair?.id &&
-        branch.condition === "Defect found.");
-}
-function supportedLoop(process) {
-    const loop = process.loops[0];
-    if (process.loops.length !== 1 || loop === undefined)
-        return false;
-    return (JSON.stringify(loop.stageIds) ===
-        JSON.stringify(executionStages(process).map((stage) => stage.id)) &&
-        loop.exitCondition === "Checks and review pass." &&
-        loop.kind === "explicit-human-instruction" &&
-        process.stoppingConditions.some((stop) => stop.id === loop.exhaustedStoppingConditionId));
-}
-function supportedGates(process) {
-    const review = executionStages(process)[0];
-    return (process.gates.every((gate) => gate.stageId === review?.id &&
-        !["exception", "rejected-approach", "assistant-claim"].includes(gate.kind)) &&
-        process.gates.filter((gate) => gate.type !== "factual-input").length <= 1);
-}
-function controlGaps(process) {
-    const stages = executionStages(process);
-    const [review, repair] = stages;
-    const loop = process.loops[0];
-    const limit = (loop?.maxIterations ?? 0) * 2;
-    return [
-        {
-            code: "ambiguous-stages",
-            supported: stages.length === 2 &&
-                review?.activity === "work" &&
-                repair?.activity === "routine-repair",
-        },
-        { code: "unsupported-branch", supported: supportedBranch(process) },
-        { code: "unsupported-loops", supported: supportedLoop(process) },
-        { code: "unsupported-gates", supported: supportedGates(process) },
-        {
-            code: "effect-limit",
-            supported: Number.isSafeInteger(limit) && limit >= 1 && limit <= 100,
-        },
-    ]
-        .filter((item) => !item.supported)
-        .map((item) => item.code);
-}
-export function generationGaps(analysis, availability) {
-    const gaps = [];
-    if (analysis.openQuestion)
-        gaps.push("unresolved-analysis-question");
-    gaps.push(...controlGaps(analysis.process));
-    for (const [module, names] of Object.entries(generationExports)) {
-        const installed = Object.hasOwn(availability.exports, module)
-            ? availability.exports[module]
-            : undefined;
-        for (const name of names)
-            if (!installed?.includes(name))
-                gaps.push(`missing-export:${module}#${name}`);
-    }
-    if (!Object.hasOwn(availability.methods, "claude"))
-        gaps.push("missing-capability:claude");
-    else if (!availability.methods["claude"]?.includes("run-turn"))
-        gaps.push("missing-method:claude#run-turn");
-    return gaps;
-}

package/dist/src/chats/workflow-generation-source.d.ts

@@ -1,25 +0,0 @@
-export declare const workflowGenerationInputBytes = 16384;
-export interface WorkflowPromptAsset {
-    readonly schemaVersion: 1;
-    readonly name: string;
-    readonly instructions: string;
-    readonly stage: {
-        readonly name: string;
-        readonly description: string;
-    };
-    readonly parameters: readonly {
-        readonly name: string;
-        readonly description: string;
-    }[];
-}
-export interface WorkflowSourceProjection {
-    readonly maximumIterations: number;
-    readonly fields: readonly string[];
-    readonly assets: readonly WorkflowPromptAsset[];
-    readonly gate: {
-        readonly name: string;
-        readonly kind: "question" | "approval";
-        readonly prompt: string;
-    } | null;
-}
-export declare function renderWorkflowSource(projection: WorkflowSourceProjection): string;

package/dist/src/chats/workflow-generation-source.js

@@ -1,124 +0,0 @@
-export const workflowGenerationInputBytes = 16_384;
-function sourceTypes(projection) {
-    return `import type { CycleOutcome, ProtectedResult } from "cloving/workflows";
-import { protectedEffect } from "cloving/workflows/steps/protected-effect";
-import { decisionGate } from "cloving/workflows/steps/decision-gate";
-type ClvInput = { cycleId: string; repository: string; input: { ${projection.fields.map((field) => `${field}: string`).join("; ")} } };
-type ClvContinuation = { gateId: string; decision: "answered" | "approved" | "denied"; answer: string | null };
-`;
-}
-function sourceChecks() {
-    return `function clvRecord(value: unknown): Record<string, unknown> | null {
-  if (value === null || typeof value !== "object" || Array.isArray(value)) return null;
-  return Object.fromEntries(Object.entries(value));
-}
-function clvStatus(result: ProtectedResult): "complete" | "repair" | "blocked" {
-  if (result.kind !== "completed" || typeof result.result !== "string") return "blocked";
-  try {
-    const envelope = clvRecord(JSON.parse(result.result));
-    const summary = envelope?.["summary"];
-    if (typeof summary !== "string" || clvBytes(summary) > 16000) return "blocked";
-    const status = clvRecord(JSON.parse(summary))?.["status"];
-    return status === "complete" || status === "repair" ? status : "blocked";
-  } catch { return "blocked"; }
-}
-function clvBlocked(cycleId: string, reason: string): CycleOutcome {
-  return { kind: "blocked", cycleId, reason, evidenceId: "clv-generation-1" };
-}
-function clvBytes(value: string): number {
-  return new TextEncoder().encode(value).length;
-}
-function clvPayload(asset: typeof clvAsset1 | typeof clvAsset2, input: ClvInput, round: number, review?: ProtectedResult, decision?: ClvContinuation): string {
-  return JSON.stringify({ asset, parameters: { cycleId: input.cycleId, repository: input.repository, input: input.input }, round, review, decision });
-}
-`;
-}
-function sourceValidation(projection) {
-    const gate = projection.gate;
-    const continuation = gate === null
-        ? "false"
-        : `value.gateId === ${JSON.stringify(gate.name)} && ${gate.kind === "question" ? 'value.decision === "answered" && typeof value.answer === "string" && value.answer.trim().length > 0 && value.answer.length <= 8000' : '(value.decision === "approved" || value.decision === "denied") && value.answer === null'}`;
-    return `function clvValidInput(value: ClvInput): boolean {
-  const envelope = clvRecord(value);
-  const fields = clvRecord(envelope?.["input"]);
-  return envelope !== null && JSON.stringify(Object.keys(envelope).sort()) === '["cycleId","input","repository"]' &&
-    typeof value.cycleId === "string" && /^[A-Za-z0-9._:-]{1,128}$/.test(value.cycleId) &&
-    typeof value.repository === "string" && value.repository.trim().length > 0 && fields !== null &&
-    JSON.stringify(Object.keys(fields).sort()) === ${JSON.stringify(JSON.stringify([...projection.fields].sort()))} &&
-    Object.values(fields).every((field) => typeof field === "string" && field.trim().length > 0) &&
-    clvBytes(JSON.stringify(fields)) <= ${String(workflowGenerationInputBytes)} &&
-    clvBytes(clvPayload(clvAsset1, value, ${String(projection.maximumIterations - 1)})) <= 32758 &&
-    clvBytes(clvPayload(clvAsset2, value, ${String(projection.maximumIterations - 1)})) <= 32758;
-}
-function clvValidContinuation(value: ClvContinuation): boolean {
-  const fields = clvRecord(value);
-  return fields !== null && JSON.stringify(Object.keys(fields).sort()) === '["answer","decision","gateId"]' && ${continuation};
-}
-`;
-}
-function sourceLoop(projection) {
-    const [review, repair] = projection.assets;
-    return `  let clvPassed = false;
-  let clvFailure: string | null = null;
-  let clvDecision: ClvContinuation | undefined;
-  for (let clvRound = 0; clvRound < ${String(projection.maximumIterations)}; clvRound++) {
-    if (clvPassed || clvFailure !== null) continue;
-    const clvReviewPayload = clvPayload(clvAsset1, input, clvRound, undefined, clvDecision);
-    if (clvBytes(clvReviewPayload) > 65536) {
-      clvFailure = "decision-too-large";
-      continue;
-    }
-    const clvReview = await protectedEffect({
-      scope: { phase: "clv-generated-1", operation: ${JSON.stringify(review?.stage.name)}, round: clvRound },
-      capability: "claude", method: "run-turn", units: 1,
-      target: input.cycleId, payload: clvReviewPayload
-    });
-    const clvReviewStatus = clvStatus(clvReview);
-    if (clvReviewStatus === "complete" && continuation?.decision === "answered" && clvDecision === undefined) {
-      clvDecision = continuation;
-      continue;
-    }
-    if (clvReviewStatus === "complete") clvPassed = true;
-    if (clvReviewStatus === "blocked") clvFailure = "worker-blocked";
-    if (clvReviewStatus !== "repair") continue;
-    const clvRepairPayload = clvPayload(clvAsset2, input, clvRound, clvReview, clvDecision);
-    if (clvBytes(JSON.stringify(clvReview)) > 32768 || clvBytes(clvRepairPayload) > 65536) {
-      clvFailure = "review-too-large";
-      continue;
-    }
-    const clvRepair = await protectedEffect({
-      scope: { phase: "clv-generated-1", operation: ${JSON.stringify(repair?.stage.name)}, round: clvRound },
-      capability: "claude", method: "run-turn", units: 1,
-      target: input.cycleId, payload: clvRepairPayload
-    });
-    if (clvStatus(clvRepair) === "blocked") clvFailure = "worker-blocked";
-  }
-  if (clvFailure !== null) return clvBlocked(input.cycleId, clvFailure);
-  if (!clvPassed) return clvBlocked(input.cycleId, "repair-limit-exhausted");
-`;
-}
-function sourceGate(projection) {
-    const gate = projection.gate;
-    if (gate === null)
-        return "";
-    return `  if (continuation === undefined) {
-    const clvGate = await decisionGate({ gateId: ${JSON.stringify(gate.name)}, kind: ${JSON.stringify(gate.kind)}, prompt: ${JSON.stringify(gate.prompt)} });
-    if (clvGate.kind !== "opened") return clvBlocked(input.cycleId, "gate-unavailable");
-    return { kind: "waiting_for_decision", cycleId: input.cycleId, decisionId: clvGate.decisionId };
-  }
-`;
-}
-export function renderWorkflowSource(projection) {
-    const assets = projection.assets
-        .map((asset, index) => `const clvAsset${String(index + 1)} = ${JSON.stringify(asset)};`)
-        .join("\n");
-    return `${sourceTypes(projection)}${assets}
-${sourceChecks()}${sourceValidation(projection)}export async function clvFunction1(input: ClvInput, continuation?: ClvContinuation): Promise<CycleOutcome> {
-  "use workflow";
-  if (!clvValidInput(input)) return clvBlocked("clv-invalid-input", "invalid-run-input");
-  if (continuation !== undefined && !clvValidContinuation(continuation)) return clvBlocked(input.cycleId, "invalid-continuation");
-  if (continuation?.decision === "denied") return clvBlocked(input.cycleId, "approval-denied");
-${sourceLoop(projection)}${sourceGate(projection)}  return { kind: "handoff_requested", cycleId: input.cycleId, promotionId: "clv-handoff-1" };
-}
-`;
-}

package/dist/src/chats/workflow-generation-text.d.ts

@@ -1,23 +0,0 @@
-import type { AnalysisResult } from "./analysis-contract.ts";
-declare const disclosureRules: readonly [{
-    readonly code: "machine-path";
-    readonly pattern: RegExp;
-}, {
-    readonly code: "parent-traversal";
-    readonly pattern: RegExp;
-}, {
-    readonly code: "email-form";
-    readonly pattern: RegExp;
-}, {
-    readonly code: "user-mention";
-    readonly pattern: RegExp;
-}, {
-    readonly code: "access-token-form";
-    readonly pattern: RegExp;
-}, {
-    readonly code: "credential-form";
-    readonly pattern: RegExp;
-}];
-export type WorkflowGenerationTextCode = "text-length" | "text-characters" | (typeof disclosureRules)[number]["code"];
-export declare function inspectWorkflowGenerationText(analysis: AnalysisResult): readonly WorkflowGenerationTextCode[];
-export {};

package/dist/src/chats/workflow-generation-text.js

@@ -1,74 +0,0 @@
-const disclosureRules = [
-    {
-        code: "machine-path",
-        pattern: /(?:^|[\s"'`=([{<,:;])(?:\/(?!\/)|\\|~(?:[a-z\d._-]+)?(?:[\\/]|$|(?=[\s"'`),;])))|(?:^|[\s"'`=([{<,;])\/\/|\b[a-z]:[a-z\d._\\/~-]|\bfile:|\$(?:\{(?:HOME|USERPROFILE|HOMEPATH|TMPDIR|APPDATA)\}|(?:env:)?(?:HOME|USERPROFILE|HOMEPATH|TMPDIR|APPDATA)\b)|%(?:HOME|USERPROFILE|HOMEPATH|TMPDIR|APPDATA)%/i,
-    },
-    {
-        code: "parent-traversal",
-        pattern: /(?:^|[\s"'`=([{<,:;\\/]|%2f|%5c)(?:\.|%2e){2}(?:[\\/]|%2f|%5c|$|(?=[\s"'`),;\]}]))/i,
-    },
-    {
-        code: "email-form",
-        pattern: /(?:[a-z\d.!#$%&'*+/=?^_`{|}~-]+|"[^"]+")@(?:[a-z\d.-]+|\[[^\]]+\])/i,
-    },
-    {
-        code: "user-mention",
-        pattern: /(?:^|[^a-z\d_.+-])@(?:[a-z\d_!&-]|\[)/i,
-    },
-    {
-        code: "access-token-form",
-        pattern: /(?:^|[^a-z\d])(?:gh[pousr]_|github_pat_|sk-(?:ant-|proj-|svcacct-)?|xox[baprs]-|npm_)[a-z\d_-]+|\b(?:AKIA|ASIA)[A-Z\d]{16}\b|\bBearer\s+\S+|\beyJ[a-z\d_-]*\.[a-z\d_-]+\.[a-z\d_-]+/i,
-    },
-    {
-        code: "credential-form",
-        pattern: /\b(?:[a-z\d_-]*(?:password|passwd|secret|token|credential|api[_-]?key|private[_-]?key)[a-z\d_-]*|api key|pwd|authorization)["']?\s*[:=]\s*\S+|\bBasic\s+[a-z\d+/]+=*|-----BEGIN (?:[A-Z\d]+ )*PRIVATE KEY(?: BLOCK)?-----|\b[a-z][a-z\d+.-]*:\/\/[^\s/?#<>]+@[^\s<>]+/i,
-    },
-];
-function renderableText(analysis) {
-    const process = analysis.process;
-    const items = [
-        ...process.inputs,
-        ...process.stages,
-        ...process.branches,
-        ...process.loops,
-        ...process.artifacts,
-        ...process.stoppingConditions,
-        ...process.gates,
-        ...process.nonGates,
-    ];
-    const texts = [
-        process.id,
-        process.name,
-        process.scope,
-        ...items.flatMap((item) => [item.id, item.description]),
-        ...process.branches.flatMap((branch) => [
-            branch.sourceStageId,
-            branch.targetStageId,
-            branch.condition,
-        ]),
-        ...process.loops.flatMap((loop) => [
-            ...loop.stageIds,
-            loop.exitCondition,
-            loop.exhaustedStoppingConditionId,
-        ]),
-        ...process.gates.map((gate) => gate.stageId),
-        ...process.nonGates.map((nonGate) => nonGate.stageId),
-    ];
-    const question = analysis.openQuestion;
-    if (question)
-        texts.push(question.claimId, question.description, ...question.choices.flatMap((choice) => [choice.id, choice.description]));
-    return texts;
-}
-export function inspectWorkflowGenerationText(analysis) {
-    const texts = renderableText(analysis);
-    const codes = [];
-    if (texts.some((text) => text.length < 1 || text.length > 240))
-        codes.push("text-length");
-    if (texts.some((text) => /[^\x20-\x7e]/u.test(text)))
-        codes.push("text-characters");
-    const bounded = texts.filter((text) => text.length > 0 && text.length <= 240);
-    for (const { code, pattern } of disclosureRules)
-        if (bounded.some((text) => pattern.test(text)))
-            codes.push(code);
-    return codes;
-}

package/dist/src/chats/workflow-generation.d.ts

@@ -1,69 +0,0 @@
-import type { AnalysisResult } from "./analysis-contract.ts";
-import type { CandidateDeclaration } from "../workflow-candidate.ts";
-import { type WorkflowPromptAsset } from "./workflow-generation-source.ts";
-import { type WorkflowGenerationTextCode } from "./workflow-generation-text.ts";
-import { type WorkflowGenerationAvailability } from "./workflow-generation-projection.ts";
-export type { WorkflowPromptAsset, WorkflowGenerationAvailability };
-declare function generationReport(analysis: AnalysisResult, gaps: readonly string[]): {
-    projection: {
-        version: "review-repair/v1";
-        stageIds: readonly string[];
-        maximumIterations: number;
-        effectLimit: number;
-    };
-    nameMap: {
-        category: string;
-        id: string;
-        name: string;
-    }[];
-    inputs: readonly import("./analysis-contract.ts").AnalysisItem[];
-    stages: {
-        disposition: "execute" | "annotation";
-        activity: import("./analysis-contract.ts").StageActivity;
-        kind: import("./analysis-contract.ts").ClaimKind;
-        sourceRefs: readonly import("./structure.ts").OccurrenceReference[];
-        counterevidenceRefs: readonly import("./structure.ts").OccurrenceReference[];
-        id: string;
-        description: string;
-    }[];
-    decisions: readonly import("./analysis-contract.ts").AnalysisGate[];
-    nonGates: readonly import("./analysis-contract.ts").AnalysisNonGate[];
-    branches: readonly import("./analysis-contract.ts").AnalysisBranch[];
-    loops: readonly import("./analysis-contract.ts").AnalysisLoop[];
-    artifacts: readonly import("./analysis-contract.ts").AnalysisItem[];
-    stoppingConditions: readonly import("./analysis-contract.ts").AnalysisItem[];
-    limitations: {
-        readonly historyCompleteness: "unknown";
-        readonly independentObservations: "not-established";
-        readonly conflictGroups: import("./structure.ts").ImportStructure["conflictGroups"];
-    };
-    gaps: readonly string[];
-    openQuestion?: import("./analysis-contract.ts").AnalysisQuestion;
-    schemaVersion: number;
-    authority: "none";
-    retention: "private-only";
-    process: {
-        id: string;
-        name: string;
-        scope: string;
-    };
-};
-export interface GeneratedWorkflowArtifact {
-    readonly functionName: string;
-    readonly source: string;
-    readonly declaration: CandidateDeclaration;
-    readonly assets: readonly WorkflowPromptAsset[];
-}
-export type WorkflowGenerationReport = ReturnType<typeof generationReport>;
-export type WorkflowGenerationResult = {
-    readonly kind: "generated";
-    readonly artifact: GeneratedWorkflowArtifact;
-    readonly report: WorkflowGenerationReport;
-} | {
-    readonly kind: "gap";
-    readonly report: WorkflowGenerationReport;
-} | {
-    readonly kind: "refused";
-    readonly codes: readonly WorkflowGenerationTextCode[];
-};
-export declare function generateWorkflow(analysis: AnalysisResult, availability: WorkflowGenerationAvailability): WorkflowGenerationResult;