@agent-plan/core 0.3.0 → 0.3.2

package/dist/load-reply.js

@@ -0,0 +1,64 @@
+import { featureNumberOfPhase, formatFeatureRef, formatPhaseRef } from "./naming.js";
+import { buildBoundedAcceptedDecisionContext } from "./task-context.js";
+export const PLANNER_LOAD_RECAP_HEADING = "## Recap — show this to the user verbatim";
+export const PLANNER_LOAD_AGENT_HEADING = "## Agent-only context — read and keep it; never quote it in the recap";
+/** Split a load reply's text back into the recap the user sees and the
+ * agent-only context. Any client (or test) that must show only the recap
+ * uses this instead of guessing at the layout. */
+export function splitPlannerLoadText(text) {
+    const agentAt = text.indexOf(PLANNER_LOAD_AGENT_HEADING);
+    const recapStart = text.startsWith(PLANNER_LOAD_RECAP_HEADING) ? PLANNER_LOAD_RECAP_HEADING.length : 0;
+    if (agentAt < 0)
+        return { recap: text.slice(recapStart).trim(), agentContext: "" };
+    return { recap: text.slice(recapStart, agentAt).trim(), agentContext: text.slice(agentAt + PLANNER_LOAD_AGENT_HEADING.length).trim() };
+}
+export function buildPlannerLoadReply(input) {
+    const guide = input.plannerGuide;
+    const guideBlock = guide.mode === "include"
+        ? ["### Agent Plan operating guide", guide.customized ? guide.message : "", guide.content].filter(Boolean).join("\n\n")
+        : [
+            "### Agent Plan operating guide",
+            `Follow the Agent Plan operating guide. If it is not already in this conversation (the /planner command includes it), read ${guide.path}.`,
+            guide.customized ? guide.message : "",
+        ].filter(Boolean).join("\n");
+    const blocks = [
+        PLANNER_LOAD_RECAP_HEADING,
+        input.recap,
+        PLANNER_LOAD_AGENT_HEADING,
+        "### Project context",
+        input.projectContext.text,
+    ];
+    if (input.scopedDecisions && input.scopedDecisions.total > 0) {
+        blocks.push("### Accepted decisions for features, phases and tasks", input.scopedDecisions.content);
+    }
+    blocks.push(guideBlock);
+    return {
+        text: blocks.join("\n\n"),
+        structured: {
+            loaded: true,
+            projectContext: input.projectContext.structured,
+            plannerGuide: guide.mode === "include"
+                ? { mode: "include", customized: guide.customized }
+                : { mode: "pointer", path: guide.path, customized: guide.customized },
+            scopedDecisions: input.scopedDecisions
+                ? { total: input.scopedDecisions.total, truncated: input.scopedDecisions.truncated }
+                : { total: 0, truncated: false },
+        },
+    };
+}
+/** Accepted Decisions owned by features, phases and tasks, bounded for a
+ * load reply. Project decisions are left out: the project context already
+ * carries them. */
+export function buildScopedDecisionContext(plan) {
+    const features = plan.features.features;
+    const phaseRef = (phase) => formatPhaseRef(phase.number, featureNumberOfPhase(phase, features));
+    const { content, total, truncated } = buildBoundedAcceptedDecisionContext([
+        ...features.map((feature) => ({ scope: `feature ${formatFeatureRef(feature.number)}`, decisions: feature.acceptedDecisions })),
+        ...plan.phases.map((phase) => ({ scope: `phase ${phaseRef(phase)}`, decisions: phase.acceptedDecisions })),
+        ...plan.phases.flatMap((phase) => phase.tasks.map((task) => ({
+            scope: `task ${phaseRef(phase)}/T${String(task.number).padStart(3, "0")}`,
+            decisions: task.acceptedDecisions,
+        }))),
+    ]);
+    return { content, total, truncated };
+}

package/dist/on-hold.d.ts

@@ -0,0 +1,59 @@
+import type { Feature, Phase } from "./schema.js";
+/**
+ * On-hold work that may be ready to resume.
+ *
+ * A task parked as deferred, waiting or blocked keeps its reason in the
+ * status log ("Resume once P097 lands"). Nothing used to look at those
+ * reasons again, so work whose blocker had finished stayed parked until a
+ * person noticed. This module is the one place that lists on-hold tasks
+ * with their reasons and checks the ones whose reason names planner refs:
+ * the recommendation and the load recap both read it, so they cannot
+ * disagree.
+ */
+export declare const ON_HOLD_STATUSES: Set<string>;
+export interface OnHoldRef {
+    /** The ref as written in the reason, normalized (e.g. `P097(F003)`, `T468`). */
+    ref: string;
+    /** Whether the named phase or task exists and is finished. */
+    finished: boolean;
+    /** False when the ref names nothing in this plan. */
+    found: boolean;
+}
+export interface OnHoldTask {
+    taskId: string;
+    ref: string;
+    title: string;
+    status: string;
+    phaseId: string;
+    phaseRef: string;
+    /** Why it was put on hold: the motivation of the status change that parked it. */
+    reason: string;
+    heldSince: string;
+    /** Planner refs the task is actually waiting on: refs named in the hold
+     *  reason, plus its own dependsOn edges (by composite ref) — deduplicated,
+     *  so a dependency already spelled out in the reason is not double-listed.
+     *  Each is checked against the plan. */
+    namedRefs: OnHoldRef[];
+    /** True when there is at least one ref to wait on (named in the reason or
+     *  a dependsOn edge) and every one of them is finished. */
+    readyToResume: boolean;
+}
+/** Resolve every planner ref named in `text`, by number only (never by title). */
+export declare function refsNamedIn(text: string, phases: Phase[], features: Feature[], selfTaskId?: string): OnHoldRef[];
+/**
+ * Every on-hold task, ready-to-resume ones first. Pass `phaseIds` to limit
+ * the list to the phases a caller is about to act on.
+ */
+export declare function listOnHoldWork(features: Feature[], phases: Phase[], phaseIds?: Set<string>): OnHoldTask[];
+/**
+ * The phases whose on-hold work matters now: phases where work has started
+ * (some task finished or in progress) but not every task is finished. A
+ * phase nobody has started yet keeps its on-hold tasks out of the way.
+ */
+export declare function startedOpenPhaseIds(phases: Phase[]): Set<string>;
+/**
+ * One bounded text block for any reply. Ready-to-resume tasks first; each
+ * line carries the reason so the agent can re-check it against the plan.
+ */
+export declare function renderOnHoldWork(items: OnHoldTask[], limit?: number): string;
+//# sourceMappingURL=on-hold.d.ts.map

package/dist/on-hold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"on-hold.d.ts","sourceRoot":"","sources":["../src/on-hold.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,KAAK,EAAQ,MAAM,aAAa,CAAC;AAGxD;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,gBAAgB,aAA8C,CAAC;AAG5E,MAAM,WAAW,SAAS;IACxB,gFAAgF;IAChF,GAAG,EAAE,MAAM,CAAC;IACZ,8DAA8D;IAC9D,QAAQ,EAAE,OAAO,CAAC;IAClB,qDAAqD;IACrD,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,kFAAkF;IAClF,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB;;;4CAGwC;IACxC,SAAS,EAAE,SAAS,EAAE,CAAC;IACvB;+DAC2D;IAC3D,aAAa,EAAE,OAAO,CAAC;CACxB;AAgBD,kFAAkF;AAClF,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,EAAE,UAAU,SAAK,GAAG,SAAS,EAAE,CA8B5G;AAoBD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,EAAE,QAAQ,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,UAAU,EAAE,CAiCzG;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,CAAC,MAAM,CAAC,CAKhE;AAID;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE,KAAK,SAAI,GAAG,MAAM,CAiBvE"}

package/dist/on-hold.js

@@ -0,0 +1,150 @@
+import { featureNumberOfPhase, formatPhaseRef } from "./naming.js";
+/**
+ * On-hold work that may be ready to resume.
+ *
+ * A task parked as deferred, waiting or blocked keeps its reason in the
+ * status log ("Resume once P097 lands"). Nothing used to look at those
+ * reasons again, so work whose blocker had finished stayed parked until a
+ * person noticed. This module is the one place that lists on-hold tasks
+ * with their reasons and checks the ones whose reason names planner refs:
+ * the recommendation and the load recap both read it, so they cannot
+ * disagree.
+ */
+export const ON_HOLD_STATUSES = new Set(["deferred", "waiting", "blocked"]);
+const FINISHED = new Set(["done", "canceled", "rejected"]);
+// A phase ref with optional feature and task, in either spelling
+// (`P097`, `P097(F003)`, `F003/P097`, `P094(F011)/T449`, `F011/P094/T449`),
+// or a bare task ref (`T468`). Word-bounded so prose like "HTTP2" or
+// "T-shirt" never matches.
+const REF_IN_TEXT = /\b(?:F(\d{1,4})\/)?P(\d{1,4})(?:\(F(\d{1,4})\))?(?:\/T(\d{1,4}))?(?!\w)|\bT(\d{1,4})(?!\w)/g;
+const pad = (n) => String(n).padStart(3, "0");
+function holdEntry(task) {
+    const entry = [...(task.statusLog ?? [])].reverse().find((log) => log.toStatus === task.status);
+    const reason = (entry?.description ?? "").replace(/^Motivation:\s*/i, "").trim();
+    return { reason, at: entry?.date ?? task.updatedAt ?? "" };
+}
+/** Resolve every planner ref named in `text`, by number only (never by title). */
+export function refsNamedIn(text, phases, features, selfTaskId = "") {
+    const phaseByNumber = new Map(phases.map((phase) => [phase.number, phase]));
+    const taskByNumber = new Map(phases.flatMap((phase) => phase.tasks.map((task) => [task.number, { phase, task }])));
+    const featureByNumber = new Map(features.map((feature) => [feature.number, feature]));
+    const seen = new Map();
+    for (const match of text.matchAll(REF_IN_TEXT)) {
+        const [, leadingFeatureNum, phaseNum, trailingFeatureNum, phaseTaskNum, bareTaskNum] = match;
+        const featureNum = trailingFeatureNum ?? leadingFeatureNum;
+        if (bareTaskNum || phaseTaskNum) {
+            const taskNum = Number(bareTaskNum ?? phaseTaskNum);
+            const hit = taskByNumber.get(taskNum);
+            const parentOk = !phaseNum || hit?.phase.number === Number(phaseNum);
+            const featureOk = !featureNum || (hit && hit.phase.featureId === featureByNumber.get(Number(featureNum))?.id);
+            const ref = phaseNum
+                ? `P${pad(Number(phaseNum))}${featureNum ? `(F${pad(Number(featureNum))})` : ""}/T${pad(taskNum)}`
+                : `T${pad(taskNum)}`;
+            if (hit?.task.id === selfTaskId)
+                continue;
+            const found = Boolean(hit && parentOk && featureOk);
+            seen.set(ref, { ref, found, finished: found && FINISHED.has(hit.task.status) });
+            continue;
+        }
+        const phase = phaseByNumber.get(Number(phaseNum));
+        const featureOk = !featureNum || (phase && phase.featureId === featureByNumber.get(Number(featureNum))?.id);
+        const ref = `P${pad(Number(phaseNum))}${featureNum ? `(F${pad(Number(featureNum))})` : ""}`;
+        const found = Boolean(phase && featureOk);
+        const finished = found && phase.tasks.length > 0 && phase.tasks.every((task) => FINISHED.has(task.status));
+        seen.set(ref, { ref, found, finished });
+    }
+    return [...seen.values()];
+}
+/** Resolve a task's dependsOn edges to composite refs, checked against the
+ *  plan the same way refsNamedIn checks a ref found in text. A dependsOn id
+ *  always resolves (dependencies are validated at creation — see
+ *  PlanStore.addTaskDependency), but a defensive `found: false` covers a
+ *  dangling edge from an older plan rather than throwing. */
+function dependencyRefsFor(task, phases, features) {
+    return (task.dependsOn ?? []).map((dependencyId) => {
+        for (const phase of phases) {
+            const dependency = phase.tasks.find((candidate) => candidate.id === dependencyId);
+            if (dependency) {
+                const ref = `${formatPhaseRef(phase.number, featureNumberOfPhase(phase, features))}/T${pad(dependency.number)}`;
+                return { ref, found: true, finished: FINISHED.has(dependency.status) };
+            }
+        }
+        return { ref: dependencyId, found: false, finished: false };
+    });
+}
+/**
+ * Every on-hold task, ready-to-resume ones first. Pass `phaseIds` to limit
+ * the list to the phases a caller is about to act on.
+ */
+export function listOnHoldWork(features, phases, phaseIds) {
+    const items = [];
+    for (const phase of phases) {
+        if (phaseIds && !phaseIds.has(phase.id))
+            continue;
+        const phaseRef = formatPhaseRef(phase.number, featureNumberOfPhase(phase, features));
+        for (const task of phase.tasks) {
+            if (!ON_HOLD_STATUSES.has(task.status))
+                continue;
+            const { reason, at } = holdEntry(task);
+            // A parked task waits on whatever its reason names AND whatever it
+            // depends on — merged by ref so a dependency already spelled out in
+            // the reason is not counted, or shown, twice.
+            const namedRefs = refsNamedIn(reason, phases, features, task.id);
+            const seenRefs = new Set(namedRefs.map((named) => named.ref));
+            for (const dependencyRef of dependencyRefsFor(task, phases, features)) {
+                if (seenRefs.has(dependencyRef.ref))
+                    continue;
+                seenRefs.add(dependencyRef.ref);
+                namedRefs.push(dependencyRef);
+            }
+            items.push({
+                taskId: task.id,
+                ref: `${phaseRef}/T${pad(task.number)}`,
+                title: task.title,
+                status: task.status,
+                phaseId: phase.id,
+                phaseRef,
+                reason,
+                heldSince: at,
+                namedRefs,
+                readyToResume: namedRefs.length > 0 && namedRefs.every((named) => named.finished),
+            });
+        }
+    }
+    return items.sort((left, right) => Number(right.readyToResume) - Number(left.readyToResume));
+}
+/**
+ * The phases whose on-hold work matters now: phases where work has started
+ * (some task finished or in progress) but not every task is finished. A
+ * phase nobody has started yet keeps its on-hold tasks out of the way.
+ */
+export function startedOpenPhaseIds(phases) {
+    return new Set(phases
+        .filter((phase) => phase.tasks.some((task) => FINISHED.has(task.status) || task.status === "in-progress"))
+        .filter((phase) => phase.tasks.some((task) => !FINISHED.has(task.status)))
+        .map((phase) => phase.id));
+}
+const REASON_PREVIEW_CHARS = 160;
+/**
+ * One bounded text block for any reply. Ready-to-resume tasks first; each
+ * line carries the reason so the agent can re-check it against the plan.
+ */
+export function renderOnHoldWork(items, limit = 8) {
+    if (items.length === 0)
+        return "";
+    const shown = items.slice(0, limit);
+    const lines = shown.map((item) => {
+        const reason = item.reason
+            ? item.reason.length > REASON_PREVIEW_CHARS ? `${item.reason.slice(0, REASON_PREVIEW_CHARS).trimEnd()}…` : item.reason
+            : "(no reason recorded)";
+        const check = item.readyToResume
+            ? ` — MAY BE READY: everything its reason names is finished (${item.namedRefs.map((named) => named.ref).join(", ")}); re-check and resume it if nothing else holds it`
+            : item.namedRefs.some((named) => !named.finished)
+                ? ` — still waiting on ${item.namedRefs.filter((named) => !named.finished).map((named) => named.found ? named.ref : `${named.ref} (not found)`).join(", ")}`
+                : "";
+        return `- ${item.ref} — ${item.title} [${item.status}]${check}\n  Reason: ${reason}`;
+    });
+    const more = items.length > shown.length ? `\n(${items.length - shown.length} more on hold; list them with the phase's task list.)` : "";
+    const ready = items.filter((item) => item.readyToResume).length;
+    return `On hold — check whether these can resume (${items.length} on hold${ready ? `, ${ready} may be ready` : ""}):\n${lines.join("\n")}${more}`;
+}

package/dist/package-version.d.ts

@@ -8,4 +8,17 @@ export interface RuntimePackageVersion {
 export declare function packageVersionFromModule(moduleUrlOrPath: string, expectedName: string): RuntimePackageVersion;
 /** Resolve a dependency exactly as the caller loaded it, then read its manifest. */
 export declare function resolvedPackageVersion(packageName: string, fromModuleUrl: string): RuntimePackageVersion;
+/**
+ * A long-lived process (an MCP server a session started, a Pi extension)
+ * keeps running the code it loaded. After an upgrade it silently runs old
+ * code, so an already-fixed bug looks like it came back. This returns a
+ * checker that re-reads the loaded package's manifest — one small file, at
+ * most once per `intervalMs` — and returns a one-line notice while the
+ * version on disk differs from the one loaded. It never throws: an
+ * unreadable manifest means no notice.
+ */
+export declare function createStaleProcessCheck(loaded: RuntimePackageVersion, { intervalMs, now }?: {
+    intervalMs?: number;
+    now?: () => number;
+}): () => string | undefined;
 //# sourceMappingURL=package-version.d.ts.map

package/dist/package-version.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"package-version.d.ts","sourceRoot":"","sources":["../src/package-version.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,+EAA+E;IAC/E,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAaD,wEAAwE;AACxE,wBAAgB,wBAAwB,CACtC,eAAe,EAAE,MAAM,EACvB,YAAY,EAAE,MAAM,GACnB,qBAAqB,CAqBvB;AAED,oFAAoF;AACpF,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,MAAM,EACnB,aAAa,EAAE,MAAM,GACpB,qBAAqB,CAGvB"}
+{"version":3,"file":"package-version.d.ts","sourceRoot":"","sources":["../src/package-version.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,+EAA+E;IAC/E,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAaD,wEAAwE;AACxE,wBAAgB,wBAAwB,CACtC,eAAe,EAAE,MAAM,EACvB,YAAY,EAAE,MAAM,GACnB,qBAAqB,CAqBvB;AAED,oFAAoF;AACpF,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,MAAM,EACnB,aAAa,EAAE,MAAM,GACpB,qBAAqB,CAGvB;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,qBAAqB,EAC7B,EAAE,UAAwB,EAAE,GAAsB,EAAE,GAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAA;CAAO,GACrG,MAAM,MAAM,GAAG,SAAS,CAmB1B"}

package/dist/package-version.js

@@ -33,3 +33,35 @@ export function resolvedPackageVersion(packageName, fromModuleUrl) {
     const entryPath = createRequire(fromModuleUrl).resolve(packageName);
     return packageVersionFromModule(entryPath, packageName);
 }
+/**
+ * A long-lived process (an MCP server a session started, a Pi extension)
+ * keeps running the code it loaded. After an upgrade it silently runs old
+ * code, so an already-fixed bug looks like it came back. This returns a
+ * checker that re-reads the loaded package's manifest — one small file, at
+ * most once per `intervalMs` — and returns a one-line notice while the
+ * version on disk differs from the one loaded. It never throws: an
+ * unreadable manifest means no notice.
+ */
+export function createStaleProcessCheck(loaded, { intervalMs = 10 * 60_000, now = () => Date.now() } = {}) {
+    let checkedAt = Number.NEGATIVE_INFINITY;
+    let notice;
+    return () => {
+        if (!loaded.packageJsonPath)
+            return undefined;
+        const time = now();
+        if (time - checkedAt < intervalMs)
+            return notice;
+        checkedAt = time;
+        notice = undefined;
+        try {
+            const manifest = JSON.parse(readFileSync(loaded.packageJsonPath, "utf-8"));
+            if (typeof manifest.version === "string" && manifest.version.trim() && manifest.version !== loaded.version) {
+                notice = `⚠️ This session is running ${loaded.name} ${loaded.version}, but ${manifest.version} is now installed. Restart the session (in Claude Code: /mcp, then reconnect agent-plan) to use it; until then, fixes made after ${loaded.version} are not active here.`;
+            }
+        }
+        catch {
+            notice = undefined;
+        }
+        return notice;
+    };
+}

package/dist/project-context.d.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { type Project, type RequirementsDocument } from "./schema.js";
 export declare const PROJECT_CONTEXT_DELIVERY_VERSION = 1;
-export declare const DEFAULT_PROJECT_CONTEXT_CHUNK_CHARS = 16000;
+export declare const DEFAULT_PROJECT_CONTEXT_CHUNK_CHARS = 32000;
 export declare const ProjectContextReadAttestationSchema: z.ZodObject<{
     sessionId: z.ZodString;
     createdAt: z.ZodString;
@@ -375,9 +375,11 @@ export declare function renderProjectContext(snapshot: ProjectContextSnapshot):
  * Every adapter (Pi, MCP, and any future harness) must deliver the same
  * complete project-level context, so the reply is shaped once here instead
  * of once per adapter — the same placement rule as handoff-reply.ts (AGENTS.md
- * rule 4). Both channels carry the full snapshot on a complete delivery:
- * some hosts surface only `text` to the agent, others only structuredContent
- * ("structuredContent-only host compatibility"), so neither is optional.
+ * rule 4). The snapshot is carried once, as rendered `text`; `structured`
+ * holds only the delivery status (complete or not, fingerprint, next
+ * actions). A host that shows the agent only structuredContent still gets
+ * the text: the MCP server folds every reply's text into its structured
+ * part (foldTextIntoStructured in plan-mcp).
  */
 export interface ProjectContextReply {
     text: string;

package/dist/project-context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"project-context.d.ts","sourceRoot":"","sources":["../src/project-context.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"project-context.d.ts","sourceRoot":"","sources":["../src/project-context.ts"],"names":[],"mappings":"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"}

package/dist/project-context.js

@@ -3,7 +3,7 @@ import { z } from "zod";
 import { AcceptedDecisionSchema, DescriptionRefSchema, MacroTaskSchema, TimestampSchema, } from "./schema.js";
 import { renderAcceptedDecisionsSection } from "./task-context.js";
 export const PROJECT_CONTEXT_DELIVERY_VERSION = 1;
-export const DEFAULT_PROJECT_CONTEXT_CHUNK_CHARS = 16_000;
+export const DEFAULT_PROJECT_CONTEXT_CHUNK_CHARS = 32_000;
 export const ProjectContextReadAttestationSchema = z.object({
     sessionId: z.string().min(1),
     createdAt: TimestampSchema,
@@ -287,9 +287,8 @@ export function buildProjectContextLoadReply(delivery, maxChars) {
         structured: {
             loaded: true,
             contextComplete: true,
-            project: delivery.snapshot.project,
-            requirements: delivery.snapshot.requirements,
             fingerprint: delivery.evidence.fingerprint,
+            requirementCount: delivery.snapshot.requirements.length,
         },
     };
 }

package/dist/recap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recap.d.ts","sourceRoot":"","sources":["../src/recap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAMjD;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC3B;AAED,yEAAyE;AACzE,MAAM,MAAM,YAAY,GAAG,IAAI,GAAG,KAAK,CAAC;AAExC,MAAM,WAAW,YAAY;IAC3B,OAAO,CAAC,EAAE,YAAY,CAAC;CACxB;AAKD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,UAAU,CAAC,EAAE,EAAE,SAAS,EAAE,GAAG,GAAE,YAAiB,EAAE,IAAI,GAAE,YAAiB,GAAG,OAAO,CAAC,MAAM,CAAC,CA2ShH"}
+{"version":3,"file":"recap.d.ts","sourceRoot":"","sources":["../src/recap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAOjD;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC3B;AAED,yEAAyE;AACzE,MAAM,MAAM,YAAY,GAAG,IAAI,GAAG,KAAK,CAAC;AAExC,MAAM,WAAW,YAAY;IAC3B,OAAO,CAAC,EAAE,YAAY,CAAC;CACxB;AAKD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,UAAU,CAAC,EAAE,EAAE,SAAS,EAAE,GAAG,GAAE,YAAiB,EAAE,IAAI,GAAE,YAAiB,GAAG,OAAO,CAAC,MAAM,CAAC,CAgThH"}

package/dist/recap.js

@@ -2,6 +2,7 @@ import { formatPhaseRef, formatTwoDigitNumber } from "./naming.js";
 import { buildPhaseWorkMap } from "./task-context.js";
 import { recommendNextTask } from "./task-selection.js";
 import { listOpenPhaseWork, openPhaseWorkLines } from "./stranded-phase.js";
+import { listOnHoldWork, renderOnHoldWork, startedOpenPhaseIds } from "./on-hold.js";
 const fref = (n) => `F${formatTwoDigitNumber(n)}`;
 const tref = (n) => `T${formatTwoDigitNumber(n)}`;
 /**
@@ -85,6 +86,11 @@ export async function buildRecap(st, web = {}, opts = {}) {
     if (openPhaseWorkText) {
         lines.push("", italian ? "In-progress: fasi con lavoro rimanente (ordine di priorità):" : "In-progress phases with work left (priority order):", openPhaseWorkText);
     }
+    // Parked work in phases already under way, with its reason and whether
+    // what it waits on has finished — the same list task_recommend shows.
+    const onHoldText = renderOnHoldWork(listOnHoldWork(feats, phases, startedOpenPhaseIds(phases)), 5);
+    if (onHoldText)
+        lines.push("", onHoldText);
     if (activeTasks.length > 1) {
         const conflicts = activeTasks.map(({ phase, task }) => {
             const feature = feats.find((entry) => entry.id === phase.featureId);

package/dist/recommend-reply.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recommend-reply.d.ts","sourceRoot":"","sources":["../src/recommend-reply.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,KAAK,EAAE,sBAAsB,EAAiB,MAAM,qBAAqB,CAAC;AAEjF,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACrC;AAED;wDACwD;AACxD,MAAM,WAAW,8BAA8B;IAC7C,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAwBD;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,sBAAsB,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,cAAc,CAsD5G"}
+{"version":3,"file":"recommend-reply.d.ts","sourceRoot":"","sources":["../src/recommend-reply.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,KAAK,EAAE,sBAAsB,EAAiB,MAAM,qBAAqB,CAAC;AAGjF,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACrC;AAED;wDACwD;AACxD,MAAM,WAAW,8BAA8B;IAC7C,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAwBD;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,sBAAsB,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,cAAc,CA8D5G"}

package/dist/recommend-reply.js

@@ -1,4 +1,5 @@
 import { featureNumberOfPhase, formatPhaseRef } from "./naming.js";
+import { renderOnHoldWork } from "./on-hold.js";
 function compositeTaskRef(candidate, features) {
     const featureNumber = featureNumberOfPhase(candidate.phase, features);
     return `${formatPhaseRef(candidate.phase.number, featureNumber)}/T${String(candidate.task.number).padStart(3, "0")}`;
@@ -32,7 +33,13 @@ function renderClaimsText(claims) {
  */
 export function buildRecommendationReply(result, features) {
     const { selection } = result;
-    const claimsText = renderClaimsText(result.claims);
+    const onHoldBlock = renderOnHoldWork(result.onHold ?? []);
+    const claimsText = `${renderClaimsText(result.claims)}${onHoldBlock ? `\n\n${onHoldBlock}` : ""}`;
+    // Counts and refs only: the reasons are in the text.
+    const onHoldSummary = {
+        total: (result.onHold ?? []).length,
+        readyToResume: (result.onHold ?? []).filter((item) => item.readyToResume).map((item) => item.ref),
+    };
     if (!selection.candidate) {
         const activeCandidates = selection.activeCandidates ?? [];
         return {
@@ -46,6 +53,7 @@ export function buildRecommendationReply(result, features) {
                 nextPhase: result.nextPhase,
                 nextTask: result.nextTask,
                 claims: result.claims,
+                onHold: onHoldSummary,
                 selection: {
                     kind: selection.kind,
                     reason: selection.reason,
@@ -73,6 +81,7 @@ export function buildRecommendationReply(result, features) {
             nextPhase: result.nextPhase,
             nextTask: result.nextTask,
             claims: result.claims,
+            onHold: onHoldSummary,
             selection: {
                 kind: selection.kind,
                 reason: selection.reason,

package/dist/task-context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"task-context.d.ts","sourceRoot":"","sources":["../src/task-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAIhG,eAAO,MAAM,mCAAmC,OAAQ,CAAC;AACzD,eAAO,MAAM,wBAAwB,OAAQ,CAAC;AAE9C,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,wBAAwB,EAAE,OAAO,CAAC;IAClC,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,sHAAsH;IACtH,OAAO,EAAE,iBAAiB,EAAE,CAAC;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,OAAO,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,uBAAuB;IACtC,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,gBAAgB,EAAE,GAAG,SAAS,CAAC;CAC3C;AAOD,8EAA8E;AAC9E,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,gBAAgB,EAAE,GAAG,SAAS,GAAG,MAAM,CAgB/G;AAED;;;GAGG;AACH,wBAAgB,mCAAmC,CACjD,MAAM,EAAE,uBAAuB,EAAE,EACjC,QAAQ,SAAsC,GAC7C;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAmB1E;AAQD,6EAA6E;AAC7E,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,KAAK,EACZ,aAAa,CAAC,EAAE,MAAM,EACtB,aAAa,CAAC,EAAE,MAAM,EACtB,QAAQ,SAA2B,GAClC,YAAY,CAmDd;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,OAAO,GAAG,SAAS,EAC5B,kBAAkB,GAAE,WAAW,EAAO,EACtC,mBAAmB,GAAE,WAAW,EAAO,EACvC,IAAI,CAAC,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,GAAG,mBAAmB,CAAC,EAC7C,OAAO,CAAC,EAAE,IAAI,CAAC,OAAO,EAAE,mBAAmB,CAAC,GAC3C,MAAM,CA0DR"}
+{"version":3,"file":"task-context.d.ts","sourceRoot":"","sources":["../src/task-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAIhG,eAAO,MAAM,mCAAmC,OAAQ,CAAC;AACzD,eAAO,MAAM,wBAAwB,OAAQ,CAAC;AAE9C,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,wBAAwB,EAAE,OAAO,CAAC;IAClC,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,sHAAsH;IACtH,OAAO,EAAE,iBAAiB,EAAE,CAAC;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,OAAO,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,uBAAuB;IACtC,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,gBAAgB,EAAE,GAAG,SAAS,CAAC;CAC3C;AAOD,8EAA8E;AAC9E,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,gBAAgB,EAAE,GAAG,SAAS,GAAG,MAAM,CAgB/G;AAED;;;GAGG;AACH,wBAAgB,mCAAmC,CACjD,MAAM,EAAE,uBAAuB,EAAE,EACjC,QAAQ,SAAsC,GAC7C;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAmB1E;AAQD,6EAA6E;AAC7E,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,KAAK,EACZ,aAAa,CAAC,EAAE,MAAM,EACtB,aAAa,CAAC,EAAE,MAAM,EACtB,QAAQ,SAA2B,GAClC,YAAY,CA6Dd;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,OAAO,GAAG,SAAS,EAC5B,kBAAkB,GAAE,WAAW,EAAO,EACtC,mBAAmB,GAAE,WAAW,EAAO,EACvC,IAAI,CAAC,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,GAAG,mBAAmB,CAAC,EAC7C,OAAO,CAAC,EAAE,IAAI,CAAC,OAAO,EAAE,mBAAmB,CAAC,GAC3C,MAAM,CA0DR"}

package/dist/task-context.js

@@ -74,19 +74,29 @@ export function buildPhaseWorkMap(phase, featureNumber, currentTaskId, maxChars
         remainingCapabilityOwner: !["done", "canceled", "rejected"].includes(task.status),
         current: task.id === currentTaskId,
     }));
-    const header = `Phase work map — canonical sibling capability ownership (${entries.length}, priority order):`;
-    const rendered = entries.map((entry) => ({
-        entry,
-        block: [
-            `- ${entry.ref}${entry.current ? " (current)" : ""} — ${entry.title} [priority ${entry.priority}; ${entry.status}]`,
-            `  Goal: ${entry.conciseGoal}`,
-            `  Depends on: ${entry.dependencies.length > 0 ? entry.dependencies.join(", ") : "None."}`,
-            entry.remainingCapabilityOwner
-                ? `  Ownership: ${entry.ref} owns this remaining capability; do not duplicate it in another task.`
-                : "  Ownership: no remaining capability ownership (terminal task).",
-        ].join("\n"),
-    }));
-    const truncationNotice = (withheldCount) => `[Phase work map truncated for transport safety: ${withheldCount} lower-priority ${withheldCount === 1 ? "entry" : "entries"} withheld. Read the canonical phase and task full views before proposing work; place deeper context under .planner/docs/.]`;
+    // Open work first, in full: that is what the agent must not duplicate and
+    // may pick up. Finished tasks follow as one line each — enough to see a
+    // capability already exists — so a long phase does not spend the reply on
+    // closed work, and the budget cuts finished lines before open ones.
+    const open = entries.filter((entry) => entry.remainingCapabilityOwner);
+    const closed = entries.filter((entry) => !entry.remainingCapabilityOwner);
+    const header = `Phase work map — canonical sibling capability ownership (${open.length} open, ${closed.length} finished; open first, priority order):`;
+    const rendered = [
+        ...open.map((entry) => ({
+            entry,
+            block: [
+                `- ${entry.ref}${entry.current ? " (current)" : ""} — ${entry.title} [priority ${entry.priority}; ${entry.status}]`,
+                `  Goal: ${entry.conciseGoal}`,
+                `  Depends on: ${entry.dependencies.length > 0 ? entry.dependencies.join(", ") : "None."}`,
+                `  Ownership: ${entry.ref} owns this remaining capability; do not duplicate it in another task.`,
+            ].join("\n"),
+        })),
+        ...closed.map((entry, index) => ({
+            entry,
+            block: `${index === 0 ? "Finished (already built; do not redo):\n" : ""}- ${entry.ref} — ${entry.title} [${entry.status}]`,
+        })),
+    ];
+    const truncationNotice = (withheldCount) => `[Phase work map truncated for transport safety: ${withheldCount} ${withheldCount === 1 ? "entry" : "entries"} withheld, finished ones first. Read the canonical phase and task full views before proposing work; place deeper context under .planner/docs/.]`;
     // Reserve space using the full task count as the withheld-count placeholder: since the
     // eventual withheld count can never exceed it, this reservation is always a safe upper
     // bound on the final notice length, so shrinking it afterward cannot overflow maxChars.

package/dist/task-move.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Move one or more tasks to a different phase without recreating them.
+ *
+ * Before this, moving a task meant deleting it and creating a new one in
+ * the target phase — losing its id, statusLog, checklist ticks, accepted
+ * decisions, pause history, and every dependsOn edge pointing at it (see
+ * P108(F005): heca's P082(F003)/T468, T470, T471, T472, T513 are on hold
+ * until work in P094 lands, but belong in P094 as its closing steps, and
+ * recreating five ~4,000-character tasks loses all of that history). This
+ * module is the one place that moves a task: only `phaseId`, `statusLog`
+ * (one appended entry) and `updatedAt` change. Everything else — id,
+ * number, shortId, status, checklist, subtasks, acceptedDecisions,
+ * pauseSnapshot/pauseHistory, notes, description/descriptionRef and
+ * dependsOn — survives untouched because the task object is spread, never
+ * rebuilt field by field. Other tasks' dependsOn keep resolving because
+ * task ids never change; only the composite ref they'd print as changes.
+ *
+ * Reply size is deliberately independent of task size: a moved task's
+ * description can be tens of thousands of characters, and a caller moving
+ * five tasks already has that text — it must not pay to receive it again.
+ * buildTaskMoveReply (below) echoes only ref/id/shortId/title/status per
+ * task, never the task body.
+ *
+ * Both phase files change together or neither: this runs inside
+ * `store.runBatch` and mirrors the rollback-on-error shape the MCP/Pi
+ * `planner-task-switch` / `task_switch` tools already use for a two-phase
+ * write (pause a task in one phase, start one in another) — collect the
+ * exact task objects removed from each source phase, and if any later step
+ * throws, add them straight back rather than reconstructing the phase's
+ * task array (which could clobber a concurrent unrelated write to that
+ * file).
+ */
+import type { PlanStore } from "./plan-store.js";
+import type { MutationReply } from "./mutation-reply.js";
+export type MoveTasksErrorCode = "NO_TASKS_GIVEN" | "TARGET_PHASE_NOT_FOUND" | "TASK_NOT_FOUND" | "SOURCE_EQUALS_TARGET" | "TARGET_PHASE_TERMINAL";
+/** One moved task, named only by ref/identity — never its description,
+ *  checklist, statusLog or any other field a caller already has. */
+export interface TaskMoveSummary {
+    taskId: string;
+    shortId: string;
+    title: string;
+    status: string;
+    oldRef: string;
+    newRef: string;
+}
+export interface MoveTasksResult {
+    targetPhaseRef: string;
+    moves: TaskMoveSummary[];
+    /** Refs of source phases that had a pending handoff at the time of the
+     *  move. A handoff is free prose and may name the moved task by ref; it
+     *  is NOT rewritten here (see buildTaskMoveReply — the reply just flags
+     *  it so a caller knows to check). */
+    sourcePhaseRefsWithHandoff: string[];
+}
+export type MoveTasksOutcome = {
+    ok: true;
+    result: MoveTasksResult;
+} | {
+    ok: false;
+    errorCode: MoveTasksErrorCode;
+    error: string;
+};
+/**
+ * Move `taskIds` (task UUIDs, already resolved by the caller) into
+ * `targetPhaseId` (a phase UUID). Validates target-exists, source != target
+ * per task, and refuses a terminal target phase — a terminal phase is
+ * closed, and reopening it by dropping new work in is not this operation's
+ * job (accepted decision on P108(F005)/T443: no override flag; unlink or
+ * reopen the phase first). An in-progress task MAY move; the reply says so.
+ */
+export declare function moveTasks(store: PlanStore, taskIds: string[], targetPhaseId: string, timestamp?: string): Promise<MoveTasksOutcome>;
+/**
+ * The one reply planner-task-move / task_move return. Deliberately NOT
+ * built with buildMutationReply: that helper echoes one entity's changed
+ * field values, and the only value that changed here — phaseId — is not
+ * something a caller refers to directly. What a caller needs per task is
+ * its old ref, its new ref, and enough identity (id/shortId/title/status)
+ * to confirm it moved — never the description, checklist or statusLog it
+ * already has and did not ask to resend.
+ */
+export declare function buildTaskMoveReply(result: MoveTasksResult, readBackCommand: string): MutationReply;
+//# sourceMappingURL=task-move.d.ts.map

package/dist/task-move.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-move.d.ts","sourceRoot":"","sources":["../src/task-move.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAGjD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD,MAAM,MAAM,kBAAkB,GAC1B,gBAAgB,GAChB,wBAAwB,GACxB,gBAAgB,GAChB,sBAAsB,GACtB,uBAAuB,CAAC;AAM5B;oEACoE;AACpE,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,eAAe;IAC9B,cAAc,EAAE,MAAM,CAAC;IACvB,KAAK,EAAE,eAAe,EAAE,CAAC;IACzB;;;0CAGsC;IACtC,0BAA0B,EAAE,MAAM,EAAE,CAAC;CACtC;AAED,MAAM,MAAM,gBAAgB,GACxB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,eAAe,CAAA;CAAE,GACrC;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,SAAS,EAAE,kBAAkB,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAMhE;;;;;;;GAOG;AACH,wBAAsB,SAAS,CAC7B,KAAK,EAAE,SAAS,EAChB,OAAO,EAAE,MAAM,EAAE,EACjB,aAAa,EAAE,MAAM,EACrB,SAAS,SAA2B,GACnC,OAAO,CAAC,gBAAgB,CAAC,CA4H3B;AAOD;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,GAAG,aAAa,CAuBlG"}