@alisio/core 0.1.1 → 0.2.0

package/dist/application.js

@@ -413,7 +413,15 @@ export async function createApplication(options = {}) {
         }
         // `exit_plan` (opt-in: only the plan agent's run sees it): the plan review hand-over.
         const { registerExitPlan } = await import("./plan/exit-plan.js");
-        registerExitPlan(registry, { store, ui: plugins.ui, readOnly: !!options.readOnly });
+        registerExitPlan(registry, {
+            store,
+            ui: plugins.ui,
+            readOnly: !!options.readOnly,
+            diagrams: () => ({
+                enabled: config.plan.diagrams,
+                max: config.plan.diagrams ? config.plan.maxDiagrams : 0,
+            }),
+        });
         // Data tools only read (effect `read`): they stay available under --read-only.
         if (config.analysis.enabled) {
             const { registerDataTools } = await import("./tools/data.js");
@@ -1152,6 +1160,13 @@ export async function createApplication(options = {}) {
                         };
                         break;
                     }
+                    case "plan.diagrams":
+                        // Read live: `exit_plan` offers (or hides) its `diagrams` field on the next request.
+                        config.plan = { ...config.plan, diagrams: value === true };
+                        break;
+                    case "plan.maxDiagrams":
+                        config.plan = { ...config.plan, maxDiagrams: Number(value) };
+                        break;
                     case "tasks.enabled":
                         // Tools are registered when the application starts: the change applies to the next
                         // application (a restart; the web recycles the workspace application).

package/dist/artifacts/chart-lint.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A cheap, deterministic quality gate for HTML dashboards: it spots the chart mistakes that models
+ * make when they hand-write charts (SVG pie arcs, fixed-size SVGs, libraries loaded from a CDN that
+ * the viewer blocks) and names the helper that avoids them. It only produces warnings for the
+ * `python_run` / `artifact_create` result; it never rejects an artifact.
+ */
+/** Warnings (empty when the page looks fine) for one HTML document. */
+export declare function chartWarnings(html: string): string[];

package/dist/artifacts/chart-lint.js

@@ -0,0 +1,84 @@
+/**
+ * A cheap, deterministic quality gate for HTML dashboards: it spots the chart mistakes that models
+ * make when they hand-write charts (SVG pie arcs, fixed-size SVGs, libraries loaded from a CDN that
+ * the viewer blocks) and names the helper that avoids them. It only produces warnings for the
+ * `python_run` / `artifact_create` result; it never rejects an artifact.
+ */
+const HELPERS = "alisio_runtime.charts (Chart.js, interactive) or alisio_runtime.svg (static)";
+/** Strips scripts and styles so a bundled library never triggers the markup checks. */
+function markupOf(html) {
+    return html
+        .replace(/(<script\b[^>]*>)[\s\S]*?<\/script\s*>/gi, "$1</script>")
+        .replace(/<style\b[^>]*>[\s\S]*?<\/style\s*>/gi, "<style></style>");
+}
+/** `d` attributes that draw a wedge: a line to/from the centre, an arc command and a close. */
+function wedgeCount(markup) {
+    let count = 0;
+    for (const match of markup.matchAll(/<path\b[^>]*?\sd\s*=\s*["']([^"']*)["']/gi)) {
+        const d = match[1] ?? "";
+        if (/[Aa]\s*[\d.]+[\s,]+[\d.]+[\s,]+-?[\d.]+[\s,]+[01][\s,]*[01]/.test(d) &&
+            /[Ll]/.test(d) &&
+            /[Zz]/.test(d))
+            count++;
+    }
+    return count;
+}
+const numeric = (value) => {
+    const match = /^\s*(\d+(?:\.\d+)?)(?:px)?\s*$/.exec(value ?? "");
+    return match ? Number(match[1]) : undefined;
+};
+/** Fixed-size SVG charts: numeric width and height, no `viewBox` (they do not scale with the card). */
+function fixedSvgCount(markup) {
+    let count = 0;
+    for (const block of markup.split(/<svg\b/i).slice(1)) {
+        const tagEnd = block.indexOf(">");
+        if (tagEnd < 0)
+            continue;
+        const tag = block.slice(0, tagEnd);
+        const body = block.slice(tagEnd, Math.max(tagEnd, block.search(/<\/svg\s*>/i)));
+        const attr = (name) => new RegExp(`\\s${name}\\s*=\\s*["']([^"']*)["']`, "i").exec(tag)?.[1];
+        const width = numeric(attr("width"));
+        const height = numeric(attr("height"));
+        const drawn = (body.match(/<(?:rect|path|polyline|circle|line)\b/gi) ?? []).length;
+        if (width !== undefined &&
+            height !== undefined &&
+            width >= 150 &&
+            drawn >= 4 &&
+            !/\sviewBox\s*=/i.test(tag))
+            count++;
+    }
+    return count;
+}
+/** `<script src>`, `<link href>` and `@import` that point at the network. */
+function remoteHosts(markup, html) {
+    const hosts = new Set();
+    const sources = [
+        ...markup.matchAll(/<script\b[^>]*\ssrc\s*=\s*["']((?:https?:)?\/\/[^"']+)["']/gi),
+        ...markup.matchAll(/<link\b[^>]*\shref\s*=\s*["']((?:https?:)?\/\/[^"']+)["']/gi),
+        ...html.matchAll(/@import\s+(?:url\()?["']?((?:https?:)?\/\/[^"')\s]+)/gi),
+    ];
+    for (const match of sources) {
+        try {
+            hosts.add(new URL(match[1].replace(/^\/\//, "https://")).host);
+        }
+        catch {
+            // Not a URL: ignore it.
+        }
+    }
+    return [...hosts];
+}
+/** Warnings (empty when the page looks fine) for one HTML document. */
+export function chartWarnings(html) {
+    const markup = markupOf(html);
+    const warnings = [];
+    const hosts = remoteHosts(markup, html);
+    if (hosts.length)
+        warnings.push(`loads resources from the network (${hosts.slice(0, 3).join(", ")}); the viewer blocks the network, so they will not load. Charts: use ${HELPERS}, which inlines Chart.js`);
+    const wedges = wedgeCount(markup);
+    if (wedges >= 2)
+        warnings.push(`${wedges} hand-written SVG arc paths look like a pie or donut; hand-written arcs are often wrong (large-arc flag, 100% slice). Use charts.pie/donut or svg.pie/donut`);
+    const fixed = fixedSvgCount(markup);
+    if (fixed)
+        warnings.push(`${fixed} SVG chart${fixed === 1 ? "" : "s"} with a fixed width and height and no viewBox will not scale with its container (small text, empty space). Use ${HELPERS}, or give the SVG a viewBox and width:100%`);
+    return warnings;
+}

package/dist/artifacts/publisher.js

@@ -8,6 +8,9 @@ export function createArtifactPublisher(store, owner, announce) {
         async publish(input) {
             return done(await store.publish(input, owner)).artifact;
         },
+        async publishDetailed(input) {
+            return done(await store.publish(input, owner));
+        },
         async publishText(input) {
             return done(await store.publishText(input, owner)).artifact;
         },

package/dist/artifacts/store.d.ts

@@ -71,7 +71,9 @@ export declare class ArtifactStore {
         title?: string;
     }): Promise<PublishedArtifact[]>;
     /** Publishes one caller-owned file or directory. */
-    publish(input: ArtifactPublishInput, owner: ArtifactOwner): Promise<PublishedArtifact>;
+    publish(input: ArtifactPublishInput & {
+        fileName?: string;
+    }, owner: ArtifactOwner): Promise<PublishedArtifact>;
     /** Publishes a single text file the caller holds in memory. */
     publishText(input: {
         fileName: string;

package/dist/artifacts/store.js

@@ -11,6 +11,7 @@ import { basename, dirname, join, relative, resolve, sep } from "node:path";
 import { newId } from "../runtime/ids.js";
 import { inside, workspaceKey } from "../runtime/paths.js";
 import { writeZip } from "../runtime/zip.js";
+import { chartWarnings } from "./chart-lint.js";
 import { classifyArtifact, isPreviewable } from "./kinds.js";
 export const DEFAULT_ARTIFACT_LIMITS = {
     maxFiles: 200,
@@ -21,6 +22,8 @@ export const DEFAULT_ARTIFACT_LIMITS = {
 export class ArtifactRejected extends Error {
 }
 const MAX_DEPTH = 8;
+/** HTML larger than this is not scanned for chart mistakes. */
+const MAX_LINT_BYTES = 8 * 1024 * 1024;
 const HEAD_BYTES = 8192;
 /** `title` → `[a-z0-9-]`, at most 48 characters (`artifact` when nothing remains). */
 export function slugify(title) {
@@ -200,6 +203,7 @@ export class ArtifactStore {
                 source: resolve(input.source),
                 ...(input.title ? { title: input.title } : {}),
                 ...(input.entry ? { entry: input.entry } : {}),
+                ...(input.fileName ? { fileName: checkName(input.fileName) } : {}),
             },
         ], owner);
         return published;
@@ -380,19 +384,25 @@ export class ArtifactStore {
                     kind = type.kind;
                     mimeType = type.mimeType;
                     fileName = only.path;
+                    if (kind === "dashboard" && only.bytes <= MAX_LINT_BYTES)
+                        for (const note of chartWarnings(await readFile(join(filesDir, only.path), "utf8")))
+                            warnings.push(`${label}: ${note}`);
                 }
                 else {
                     entry = plan.entry;
                     const type = classifyArtifact(entry, await readHead(join(filesDir, ...entry.split("/"))));
                     kind = type.kind;
                     mimeType = type.mimeType;
-                    fileName = files.length > 1 ? `${baseName}.zip` : basename(entry);
+                    fileName =
+                        plan.candidate.fileName ?? (files.length > 1 ? `${baseName}.zip` : basename(entry));
                     if (type.kind === "dashboard") {
                         const html = await readFile(join(filesDir, ...entry.split("/")), "utf8");
                         const entryDir = entry.includes("/") ? entry.slice(0, entry.lastIndexOf("/")) : "";
                         const missing = missingReferences(html, entryDir, new Set(files.map((f) => f.path)));
                         if (missing.length)
                             warnings.push(`${label}: ${entry} references missing files: ${missing.join(", ")}`);
+                        for (const note of chartWarnings(html))
+                            warnings.push(`${label}: ${entry} ${note}`);
                     }
                 }
             }

package/dist/changelog/data.js

@@ -2,9 +2,40 @@
 export const CHANGELOG_DATA = {
     schema: 1,
     entries: [
+        {
+            version: "0.2.0",
+            date: "2026-10-02",
+            sections: [
+                {
+                    title: "Added",
+                    items: [
+                        "Plan diagrams: the plan agent can attach small Mermaid diagrams (flows, sequences, architecture) to the plan it proposes with `exit_plan`.",
+                        "A plan viewer in the web UI: the plan opens in the artifact panel with its diagrams drawn in your theme, next to the plan review. The terminal shows the diagram source.",
+                        "Plan files are saved in a plan folder with a `plan.json` manifest, so the plan and its diagrams are easy to find and reuse.",
+                        "Two new settings, `plan.diagrams` and `plan.maxDiagrams` (in the configuration file, **Settings** in the web and `/settings` in the terminal), to turn diagrams off or cap how many a plan keeps.",
+                        "Dashboard charts for Python analysis: `alisio_runtime.charts` builds interactive pie, donut, bar, line, area and scatter charts, KPI tiles and cards with an embedded Chart.js (MIT), so dashboards work offline, in the viewer and in the downloaded file.",
+                    ],
+                },
+                {
+                    title: "Improved",
+                    items: [
+                        "Charts adapt to their card and follow the light and dark theme, with value labels, tooltips and a data table for screen readers.",
+                        "The pure-SVG helpers (`alisio_runtime.svg`) were rewritten: they scale with their container and carry a title and description.",
+                        "The agent receives clearer guidance for `python_run` about how to draw charts and dashboards.",
+                    ],
+                },
+                {
+                    title: "Fixed",
+                    items: [
+                        "Pie charts drew wrong or broken slices in generated dashboards (including a single 100% slice), and bar charts rendered at a fixed small size.",
+                        "A dashboard that draws SVG pies by hand, uses fixed-size SVG charts or loads a script from the network now gets a warning in the `python_run` result that points to the chart helpers.",
+                    ],
+                },
+            ],
+        },
         {
             version: "0.1.1",
-            date: "2026-10-03",
+            date: "2026-10-02",
             sections: [
                 {
                     title: "Fixed",

package/dist/config.d.ts

@@ -231,6 +231,10 @@ export declare const configSchema: z.ZodPipe<z.ZodObject<{
         noToolTurnsLimit: z.ZodDefault<z.ZodNumber>;
         blockedRepeats: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strict>>;
+    plan: z.ZodDefault<z.ZodObject<{
+        diagrams: z.ZodDefault<z.ZodBoolean>;
+        maxDiagrams: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
     tui: z.ZodDefault<z.ZodObject<{
         paddingX: z.ZodDefault<z.ZodNumber>;
         contentPaddingX: z.ZodDefault<z.ZodNumber>;
@@ -338,6 +342,10 @@ export declare const configSchema: z.ZodPipe<z.ZodObject<{
         noToolTurnsLimit: number;
         blockedRepeats: number;
     };
+    plan: {
+        diagrams: boolean;
+        maxDiagrams: number;
+    };
     tui: {
         paddingX: number;
         contentPaddingX: number;
@@ -528,6 +536,10 @@ export declare const configSchema: z.ZodPipe<z.ZodObject<{
         noToolTurnsLimit: number;
         blockedRepeats: number;
     };
+    plan: {
+        diagrams: boolean;
+        maxDiagrams: number;
+    };
     tui: {
         paddingX: number;
         contentPaddingX: number;
@@ -643,6 +655,8 @@ declare const SETTABLE_KEYS: {
     readonly "goal.repeatedReplyLimit": z.ZodDefault<z.ZodNumber>;
     readonly "goal.noToolTurnsLimit": z.ZodDefault<z.ZodNumber>;
     readonly "goal.blockedRepeats": z.ZodDefault<z.ZodNumber>;
+    readonly "plan.diagrams": z.ZodDefault<z.ZodBoolean>;
+    readonly "plan.maxDiagrams": z.ZodDefault<z.ZodNumber>;
 };
 export type SettableSettingKey = keyof typeof SETTABLE_KEYS;
 export declare function isSettableSettingKey(key: string): key is SettableSettingKey;

package/dist/config.js

@@ -386,6 +386,18 @@ const configObjectSchema = z
         noToolTurnsLimit: 3,
         blockedRepeats: 2,
     })),
+    /**
+     * Plan diagrams (`exit_plan`): the plan agent may add Mermaid diagrams to a plan. `diagrams`
+     * off removes them from the tool and from the agent's instructions; `maxDiagrams` caps how
+     * many one plan keeps (0 to 8). The size and node limits of one diagram are constants.
+     */
+    plan: z
+        .object({
+        diagrams: z.boolean().default(true),
+        maxDiagrams: z.number().int().min(0).max(8).default(5),
+    })
+        .strict()
+        .default(() => ({ diagrams: true, maxDiagrams: 5 })),
     tui: z
         .object({
         /** Horizontal padding (columns) around the editor input box. Editor-only. */
@@ -767,6 +779,7 @@ const SETTABLE_SECTIONS = {
     analysis: configObjectSchema.shape.analysis.removeDefault(),
     tasks: configObjectSchema.shape.tasks.removeDefault(),
     goal: configObjectSchema.shape.goal.removeDefault(),
+    plan: configObjectSchema.shape.plan.removeDefault(),
 };
 const ANALYSIS_LIMITS = SETTABLE_SECTIONS.analysis.shape.limits.removeDefault();
 const ANALYSIS_RETENTION = SETTABLE_SECTIONS.analysis.shape.retention.removeDefault();
@@ -807,6 +820,8 @@ const SETTABLE_KEYS = {
     "goal.repeatedReplyLimit": SETTABLE_SECTIONS.goal.shape.repeatedReplyLimit,
     "goal.noToolTurnsLimit": SETTABLE_SECTIONS.goal.shape.noToolTurnsLimit,
     "goal.blockedRepeats": SETTABLE_SECTIONS.goal.shape.blockedRepeats,
+    "plan.diagrams": SETTABLE_SECTIONS.plan.shape.diagrams,
+    "plan.maxDiagrams": SETTABLE_SECTIONS.plan.shape.maxDiagrams,
 };
 export function isSettableSettingKey(key) {
     return Object.prototype.hasOwnProperty.call(SETTABLE_KEYS, key);

package/dist/core/contracts.d.ts

@@ -1,4 +1,4 @@
-import type { AnalysisCapability, ArtifactPublisher, ArtifactRef, CompactionCheckpoint, InstallPreview, Message, ToolCall, ToolResult } from "@alisio/sdk";
+import type { AnalysisCapability, ArtifactPublisher, ArtifactPublishInput, ArtifactRef, CompactionCheckpoint, InstallPreview, Message, ToolCall, ToolResult } from "@alisio/sdk";
 export interface Session {
     id: string;
     workspace: string;
@@ -255,6 +255,13 @@ export interface CoreArtifactPublisher extends ArtifactPublisher {
         partial?: boolean;
         provenance?: Record<string, unknown>;
     }): Promise<PublishedArtifactInfo[]>;
+    /**
+     * Detailed variant of `publish` (path and warnings). `fileName` names a multi-file folder with
+     * an `entry` after its main file (`plan.md`) instead of `<folder>.zip`; downloads are still ZIPs.
+     */
+    publishDetailed(input: ArtifactPublishInput & {
+        fileName?: string;
+    }): Promise<PublishedArtifactInfo>;
     /** Detailed variant of `publishText` (path and warnings). */
     publishTextDetailed(input: {
         fileName: string;

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 /** @alisio/core public API: embed the Alisio agent programmatically. */
 export * from "@alisio/sdk";
-export { type ActiveAgent, AGENT_COMMAND_PREFIX, type AgentPickerItem, activeAgentCatalog, agentCatalogFromState, agentCommandDescriptors, agentCommandName, agentIdFromCommand, agentPickerItems, agentRunOptions, BUILTIN_AGENTS, cycleableAgents, DEFAULT_AGENT_ID, type MainCapableAgentRecord, mainAgentFromRecord, nextAgent, PLAN_AGENT_ID, resolveActiveAgent, } from "./agents/active.ts";
+export { type ActiveAgent, AGENT_COMMAND_PREFIX, type AgentPickerItem, activeAgentCatalog, agentCatalogFromState, agentCommandDescriptors, agentCommandName, agentIdFromCommand, agentPickerItems, agentRunOptions, BUILTIN_AGENTS, cycleableAgents, DEFAULT_AGENT_ID, type MainCapableAgentRecord, mainAgentFromRecord, nextAgent, PLAN_AGENT_ID, type PlanInstructionSettings, planInstructions, resolveActiveAgent, } from "./agents/active.ts";
 export { agentModelCapabilities, agentModelLabels, agentModelOptions, DEFAULT_EFFORT_LEVELS, fitAgentSettings, } from "./agents/capabilities.ts";
 export { AGENT_AUTHORING_SKILL_NAMES, CREATE_AGENT_SKILL, } from "./agents/create-agent-skill.ts";
 export { AGENT_ID_PATTERN, AGENT_LIMITS, AGENT_REASONING_SUMMARIES, AGENT_TEXT_FORMATS, AGENT_VERBOSITIES, type AgentFieldError, AgentNotFoundError, AgentScopeStore, agentIdFromName, agentScopeDir, parseAgentFile, RESERVED_AGENT_IDS, slugify, validateAgentDefinitionInput, } from "./agents/definitions.ts";
@@ -43,6 +43,8 @@ export * from "./goal/index.ts";
 export { HerdrBridge } from "./integrations/herdr.ts";
 export { McpConnector, type McpServerInfo, type McpStatus, type McpToolInfo, } from "./mcp/connector.ts";
 export { describePermissionStatus, type EffectState, effectState, FULL_ACCESS_WARNING, type ModeFlags, type ModePolicy, modeFromFlags, modeToPreset, PERMISSION_MODE_TABLE, PERMISSION_MODES, PERMISSION_MODES_LOCKED, PERMISSION_USAGE, type PermissionCommand, type PermissionModeLabel, type PermissionModeSpec, parsePermissionCommand, parsePermissionMode, presetToMode, READ_ONLY_POLICY, } from "./permissions/modes.ts";
+export { DIAGRAM_MAX_BYTES, DIAGRAM_MAX_NODES, DIAGRAM_SYNTAXES, DIAGRAMS_MAX_ALLOWED, mermaidProblem, type PlanDiagram, validateDiagrams, } from "./plan/diagrams.ts";
+export { buildPlanManifest, parsePlanHeadings, slugifyHeading, } from "./plan/manifest.ts";
 export { claimApprovedPlan, currentPlan, discardApprovedPlan, IMPLEMENTATION_AGENT_ID, implementationPrompt, PLAN_CONTEXT_MAX_CHARS, PLAN_OPTIONS, PLAN_QUESTION_ID, PLAN_REVIEW_TITLE, PLAN_TEXT_KEY, type PlanFollowUp, type PlanState, type PlanStatus, planHash, readPlanState, settlePlanRun, withdrawPendingPlan, } from "./plan/state.ts";
 export { discoverPlugins, PluginHost, type PluginHostOptions, pluginPrefix, type ViewInfo, ViewRunError, } from "./plugins/host.ts";
 export { type CliInstallOptions, cliInstall, INSTALL_TIMEOUT_MS, type InstallPluginInput, type InstallPluginResult, type InstallRunner, installedNpmPlugins, installPlugin, npmInstallTarget, type PluginSpec, parsePluginSpec, pluginTrustRemark, printInstallResult, registerPluginInstallTool, sanitizeNpmError, } from "./plugins/install.ts";

package/dist/index.js

@@ -1,6 +1,6 @@
 /** @alisio/core public API: embed the Alisio agent programmatically. */
 export * from "@alisio/sdk";
-export { AGENT_COMMAND_PREFIX, activeAgentCatalog, agentCatalogFromState, agentCommandDescriptors, agentCommandName, agentIdFromCommand, agentPickerItems, agentRunOptions, BUILTIN_AGENTS, cycleableAgents, DEFAULT_AGENT_ID, mainAgentFromRecord, nextAgent, PLAN_AGENT_ID, resolveActiveAgent, } from "./agents/active.js";
+export { AGENT_COMMAND_PREFIX, activeAgentCatalog, agentCatalogFromState, agentCommandDescriptors, agentCommandName, agentIdFromCommand, agentPickerItems, agentRunOptions, BUILTIN_AGENTS, cycleableAgents, DEFAULT_AGENT_ID, mainAgentFromRecord, nextAgent, PLAN_AGENT_ID, planInstructions, resolveActiveAgent, } from "./agents/active.js";
 export { agentModelCapabilities, agentModelLabels, agentModelOptions, DEFAULT_EFFORT_LEVELS, fitAgentSettings, } from "./agents/capabilities.js";
 export { AGENT_AUTHORING_SKILL_NAMES, CREATE_AGENT_SKILL, } from "./agents/create-agent-skill.js";
 export { AGENT_ID_PATTERN, AGENT_LIMITS, AGENT_REASONING_SUMMARIES, AGENT_TEXT_FORMATS, AGENT_VERBOSITIES, AgentNotFoundError, AgentScopeStore, agentIdFromName, agentScopeDir, parseAgentFile, RESERVED_AGENT_IDS, slugify, validateAgentDefinitionInput, } from "./agents/definitions.js";
@@ -42,6 +42,8 @@ export * from "./goal/index.js";
 export { HerdrBridge } from "./integrations/herdr.js";
 export { McpConnector, } from "./mcp/connector.js";
 export { describePermissionStatus, effectState, FULL_ACCESS_WARNING, modeFromFlags, modeToPreset, PERMISSION_MODE_TABLE, PERMISSION_MODES, PERMISSION_MODES_LOCKED, PERMISSION_USAGE, parsePermissionCommand, parsePermissionMode, presetToMode, READ_ONLY_POLICY, } from "./permissions/modes.js";
+export { DIAGRAM_MAX_BYTES, DIAGRAM_MAX_NODES, DIAGRAM_SYNTAXES, DIAGRAMS_MAX_ALLOWED, mermaidProblem, validateDiagrams, } from "./plan/diagrams.js";
+export { buildPlanManifest, parsePlanHeadings, slugifyHeading, } from "./plan/manifest.js";
 export { claimApprovedPlan, currentPlan, discardApprovedPlan, IMPLEMENTATION_AGENT_ID, implementationPrompt, PLAN_CONTEXT_MAX_CHARS, PLAN_OPTIONS, PLAN_QUESTION_ID, PLAN_REVIEW_TITLE, PLAN_TEXT_KEY, planHash, readPlanState, settlePlanRun, withdrawPendingPlan, } from "./plan/state.js";
 export { discoverPlugins, PluginHost, pluginPrefix, ViewRunError, } from "./plugins/host.js";
 export { cliInstall, INSTALL_TIMEOUT_MS, installedNpmPlugins, installPlugin, npmInstallTarget, parsePluginSpec, pluginTrustRemark, printInstallResult, registerPluginInstallTool, sanitizeNpmError, } from "./plugins/install.js";

package/dist/plan/diagrams.d.ts

@@ -0,0 +1,76 @@
+import type { PlanDiagramType } from "@alisio/sdk";
+/** Largest Mermaid source of one diagram (UTF-8 bytes). */
+export declare const DIAGRAM_MAX_BYTES: number;
+/** Most nodes (participants, entities, states, tasks...) of one diagram, estimated from the text. */
+export declare const DIAGRAM_MAX_NODES = 40;
+/** Hard ceiling of `plan.maxDiagrams`. */
+export declare const DIAGRAMS_MAX_ALLOWED = 8;
+export declare const DIAGRAM_ID_MAX = 40;
+export declare const DIAGRAM_TITLE_MAX = 80;
+export declare const DIAGRAM_EXPLANATION_MAX = 400;
+export declare const DIAGRAM_SECTION_MAX = 120;
+/** Mermaid diagram keywords a plan may use (the first statement of the source). */
+export declare const DIAGRAM_SYNTAXES: readonly string[];
+export declare const DIAGRAM_TYPES: readonly PlanDiagramType[];
+/**
+ * The semantic classes of the style guide. The web applies the same names as a `classDef` block
+ * at render time when a diagram uses a class without defining it (colors live in the web).
+ */
+export declare const DIAGRAM_CLASSES: readonly string[];
+export interface PlanDiagram {
+    id: string;
+    title: string;
+    explanation: string;
+    /** As the model wrote it; the manifest resolves it against the plan headings. */
+    section?: string;
+    type: PlanDiagramType;
+    syntax: string;
+    mermaid: string;
+    nodes: number;
+}
+export interface DroppedDiagram {
+    /** The id as given (or `#<position>` when it has none). */
+    id: string;
+    reason: string;
+}
+export interface DiagramValidation {
+    accepted: PlanDiagram[];
+    dropped: DroppedDiagram[];
+}
+export interface DiagramLimits {
+    /** Most diagrams of one plan (0 accepts none). */
+    max: number;
+    maxBytes?: number;
+    maxNodes?: number;
+}
+/** Normalizes line endings and trims: what is stored and hashed. */
+export declare const normalizeMermaid: (source: string) => string;
+/** The diagram keyword of a source (its first statement), or undefined when it has none. */
+export declare function diagramSyntax(source: string): string | undefined;
+/** The purpose a syntax implies when the model gave none. */
+export declare function defaultDiagramType(syntax: string): PlanDiagramType;
+/**
+ * An estimate of the diagram's nodes from its text (participants, entities, states, tasks, topics
+ * or flowchart node ids). It errs on the high side: it is a guard against walls of boxes, not a
+ * parser.
+ */
+export declare function estimateNodes(source: string, syntax: string): number;
+/** The first problem that makes a Mermaid source unsafe or unsupported, or undefined when fine. */
+export declare function mermaidProblem(source: string, limits?: {
+    maxBytes?: number;
+    maxNodes?: number;
+}): string | undefined;
+/** SHA-256 of what makes a diagram "the same" across revisions. */
+export declare function diagramHash(diagram: {
+    title: string;
+    explanation: string;
+    section?: string;
+    type: string;
+    mermaid: string;
+}): string;
+/**
+ * Validates the `diagrams` argument of `exit_plan`. Never throws: every problem becomes a dropped
+ * diagram with the reason the model needs to fix it. Order is kept; the first diagram with an id
+ * wins; only `limits.max` are accepted.
+ */
+export declare function validateDiagrams(input: unknown, limits: DiagramLimits): DiagramValidation;