@miadi/plan-insight 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Miadi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,91 @@
+# `@miadi/plan-insight`
+
+Capability-injected orchestration for interpreting a plan without pretending that interpretation infrastructure exists.
+
+`@miadi/plan-insight` receives a plan plus provenance, requires real perspective, chart, trace, and memory capabilities, runs them in order, and returns deterministic artifact wrappers together with a validated `miadi.miette.perspective.ready` event.
+
+## Install
+
+```bash
+npm install @miadi/plan-insight
+```
+
+## Boundary
+
+This package owns:
+
+- validating the minimum plan-insight request;
+- deterministic run and artifact IDs;
+- required-capability preflight;
+- ordered perspective → chart → trace → memory orchestration;
+- typed, stage-specific failures;
+- hooks-core perspective discovery and ready-event composition.
+
+The injected capabilities own all interpretation and side effects. The package does not generate Mia/Miette prose, create structural-tension charts, contact tracing services, write memory, call an LLM, scan arbitrary host paths, use SSH, or load credentials.
+
+The existing Next.js route at `app/api/session/plan-insight` is a **future consumer**. It is not this package's transport or runtime boundary.
+
+## Required capabilities
+
+```ts
+import { runPlanInsight } from "@miadi/plan-insight"
+
+const result = await runPlanInsight(input, {
+  perspective: perspectiveProvider,
+  chart: chartProvider,
+  trace: traceProvider,
+  memory: memoryProvider,
+})
+```
+
+All four capabilities must be own data properties. Missing capabilities fail before any capability runs. Accessor registries, malformed outputs, provider failures, and hooks-core contract failures produce `PlanInsightError` with an explicit `code` and `stage`.
+
+Each capability receives the caller's plan/provenance context and deterministic IDs. Provider references remain available as `externalId`; provider provenance remains attached to its artifact.
+
+## hooks-core reuse
+
+The package consumes `@miadi/hooks-core@0.4.0` rather than redefining:
+
+- `deriveIdempotencyKey`;
+- `discoverPlanPerspectives`;
+- `perspectiveReadyEventFromRecord`;
+- `validatePlanReviewEvent`;
+- `planReviewIdempotencyKey`;
+- plan provenance, source, perspective record, and ready-event types.
+
+Use `discoverPlanInsightPerspectives(root, options)` when a consumer needs existing session perspectives lifted into deterministic, validated ready events.
+
+## Memory contract
+
+The memory capability returns `EpisodicMemory` from `@miadi/episodic-memory-schema@0.2.0`. In this CommonJS release that package is consumed as a **type-only** dependency; no CommonJS runtime import of its ESM entrypoint is emitted.
+
+Plan Insight does not consume or duplicate `EpisodeObservation`, and it does not perform Chronicle promotion.
+
+## Provenance and determinism
+
+The caller supplies timestamps and provenance. IDs derive from hooks-core's stable idempotency function over the plan, episode key, source, and provenance. The package does not call the clock or generate random IDs.
+
+Capability artifacts receive deterministic package IDs while real provider/service IDs are preserved separately as `externalId`.
+
+Each capability receives an isolated snapshot of the canonical request and prepared IDs. Provider mutation cannot rewrite the provenance or deterministic IDs used for later stages, events, or the final result.
+
+## Non-goals for 0.1.0
+
+- CLI
+- HTTP routes or job storage
+- provider implementations
+- fake or deterministic substitute interpretations
+- Passages or Forgewright integration
+- episode registration/publication
+- LLM, MCP, Langfuse, Medicine Wheel, or filesystem wiring
+
+## Development
+
+```bash
+npm test
+npm run type-check
+npm run build
+npm pack --dry-run
+```
+
+`TDD-EVIDENCE.md` records the red/green sequence used for each 0.1.0 behavior.

package/dist/discovery.d.ts

@@ -0,0 +1,2 @@
+import type { DiscoveredPlanInsightPerspective, DiscoverPlanInsightPerspectivesOptions } from "./types";
+export declare function discoverPlanInsightPerspectives(rootDir: string, options: DiscoverPlanInsightPerspectivesOptions): DiscoveredPlanInsightPerspective[];

package/dist/discovery.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverPlanInsightPerspectives = discoverPlanInsightPerspectives;
+const hooks_core_1 = require("@miadi/hooks-core");
+function discoverPlanInsightPerspectives(rootDir, options) {
+    return (0, hooks_core_1.discoverPlanPerspectives)(rootDir).map((record) => {
+        const seed = (0, hooks_core_1.deriveIdempotencyKey)({
+            sessionId: record.session_id,
+            agent: options.source.agent ?? options.source.system,
+            nativeEvent: "miadi.miette.perspective.ready",
+            payload: {
+                episode_key: options.episodeKey,
+                record,
+                source: options.source,
+                plan_pane_id: options.planPaneId ?? "unknown",
+            },
+        });
+        const event = (0, hooks_core_1.perspectiveReadyEventFromRecord)(record, {
+            episode_key: options.episodeKey,
+            source: { ...options.source },
+            plan_pane_id: options.planPaneId,
+            event_id: `evt_plan_insight_discovery_${seed.slice(0, 24)}`,
+            occurred_at: record.modified_at,
+        });
+        const validation = (0, hooks_core_1.validatePlanReviewEvent)(event);
+        return {
+            record,
+            event,
+            validation,
+            idempotencyKey: (0, hooks_core_1.planReviewIdempotencyKey)(event),
+        };
+    });
+}

package/dist/errors.d.ts

@@ -0,0 +1,11 @@
+export type PlanInsightErrorCode = "request.invalid" | "capability.missing" | "capability.failed" | "contract.invalid";
+export type PlanInsightStage = "request" | "perspective" | "chart" | "trace" | "memory" | "contract";
+export declare class PlanInsightError extends Error {
+    readonly code: PlanInsightErrorCode;
+    readonly stage: PlanInsightStage;
+    readonly details?: Record<string, unknown>;
+    constructor(code: PlanInsightErrorCode, stage: PlanInsightStage, message: string, options?: {
+        cause?: unknown;
+        details?: Record<string, unknown>;
+    });
+}

package/dist/errors.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlanInsightError = void 0;
+class PlanInsightError extends Error {
+    code;
+    stage;
+    details;
+    constructor(code, stage, message, options = {}) {
+        super(message, options.cause === undefined ? undefined : { cause: options.cause });
+        this.name = "PlanInsightError";
+        this.code = code;
+        this.stage = stage;
+        this.details = options.details;
+    }
+}
+exports.PlanInsightError = PlanInsightError;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { PlanInsightError } from "./errors";
+export type { PlanInsightErrorCode, PlanInsightStage, } from "./errors";
+export { discoverPlanInsightPerspectives } from "./discovery";
+export { preparePlanInsight } from "./prepare";
+export { runPlanInsight } from "./orchestrator";
+export type { CapabilityOutput, ChartCapability, DiscoveredPlanInsightPerspective, DiscoverPlanInsightPerspectivesOptions, MemoryCapability, PerspectiveCapability, PerspectiveCapabilityOutput, PlanInsightArtifact, PlanInsightArtifactIds, PlanInsightBaseContext, PlanInsightCapabilities, PlanInsightCapabilityName, PlanInsightInput, PlanInsightProvenance, PlanInsightResult, PreparedPlanInsight, TraceCapability, } from "./types";

package/dist/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPlanInsight = exports.preparePlanInsight = exports.discoverPlanInsightPerspectives = exports.PlanInsightError = void 0;
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "PlanInsightError", { enumerable: true, get: function () { return errors_1.PlanInsightError; } });
+var discovery_1 = require("./discovery");
+Object.defineProperty(exports, "discoverPlanInsightPerspectives", { enumerable: true, get: function () { return discovery_1.discoverPlanInsightPerspectives; } });
+var prepare_1 = require("./prepare");
+Object.defineProperty(exports, "preparePlanInsight", { enumerable: true, get: function () { return prepare_1.preparePlanInsight; } });
+var orchestrator_1 = require("./orchestrator");
+Object.defineProperty(exports, "runPlanInsight", { enumerable: true, get: function () { return orchestrator_1.runPlanInsight; } });

package/dist/orchestrator.d.ts

@@ -0,0 +1,2 @@
+import type { PlanInsightCapabilities, PlanInsightInput, PlanInsightResult } from "./types";
+export declare function runPlanInsight<P = unknown, C = unknown, T = unknown>(input: PlanInsightInput, capabilities: Partial<PlanInsightCapabilities<P, C, T>> | null | undefined): Promise<PlanInsightResult<P, C, T>>;

package/dist/orchestrator.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPlanInsight = runPlanInsight;
+const hooks_core_1 = require("@miadi/hooks-core");
+const errors_1 = require("./errors");
+const prepare_1 = require("./prepare");
+const REQUIRED_CAPABILITIES = [
+    "perspective",
+    "chart",
+    "trace",
+    "memory",
+];
+function resolveCapabilities(registry) {
+    if (registry === null || typeof registry !== "object") {
+        throw new errors_1.PlanInsightError("capability.missing", "request", `Missing required Plan Insight capabilities: ${REQUIRED_CAPABILITIES.join(", ")}`, { details: { missing: [...REQUIRED_CAPABILITIES] } });
+    }
+    let descriptors;
+    try {
+        descriptors = Object.getOwnPropertyDescriptors(registry);
+    }
+    catch (cause) {
+        throw new errors_1.PlanInsightError("contract.invalid", "request", "Capability registry descriptors could not be inspected safely", { cause });
+    }
+    const accessors = REQUIRED_CAPABILITIES.filter((name) => {
+        const descriptor = descriptors[name];
+        return descriptor !== undefined && !("value" in descriptor);
+    });
+    if (accessors.length > 0) {
+        throw new errors_1.PlanInsightError("contract.invalid", "request", "Capability registry must use own data properties, not accessors", { details: { accessors } });
+    }
+    const missing = REQUIRED_CAPABILITIES.filter((name) => typeof descriptors[name]?.value !== "function");
+    if (missing.length > 0) {
+        throw new errors_1.PlanInsightError("capability.missing", "request", `Missing required Plan Insight capabilities: ${missing.join(", ")}`, { details: { missing } });
+    }
+    return Object.fromEntries(REQUIRED_CAPABILITIES.map((name) => [name, descriptors[name].value]));
+}
+async function executeCapability(stage, execute) {
+    try {
+        return await execute();
+    }
+    catch (cause) {
+        throw new errors_1.PlanInsightError("capability.failed", stage, `${stage} capability failed`, { cause });
+    }
+}
+function normalizeCapabilityOutput(stage, raw) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        throw new errors_1.PlanInsightError("contract.invalid", stage, `${stage} capability must return a CapabilityOutput object`);
+    }
+    let descriptors;
+    try {
+        descriptors = Object.getOwnPropertyDescriptors(raw);
+    }
+    catch (cause) {
+        throw new errors_1.PlanInsightError("contract.invalid", stage, `${stage} capability output could not be inspected safely`, { cause });
+    }
+    for (const field of ["value", "externalId", "provenance"]) {
+        const descriptor = descriptors[field];
+        if (descriptor !== undefined && !("value" in descriptor)) {
+            throw new errors_1.PlanInsightError("contract.invalid", stage, `${stage} capability output must use data properties`, { details: { field } });
+        }
+    }
+    if (!("value" in (descriptors.value ?? {})) || descriptors.value.value === undefined) {
+        throw new errors_1.PlanInsightError("contract.invalid", stage, `${stage} capability output requires a defined value`);
+    }
+    if (descriptors.externalId?.value !== undefined &&
+        typeof descriptors.externalId.value !== "string") {
+        throw new errors_1.PlanInsightError("contract.invalid", stage, `${stage} capability externalId must be a string when present`);
+    }
+    if (descriptors.provenance?.value !== undefined &&
+        (typeof descriptors.provenance.value !== "object" ||
+            descriptors.provenance.value === null ||
+            Array.isArray(descriptors.provenance.value))) {
+        throw new errors_1.PlanInsightError("contract.invalid", stage, `${stage} capability provenance must be an object when present`);
+    }
+    return {
+        value: descriptors.value.value,
+        externalId: descriptors.externalId?.value,
+        provenance: descriptors.provenance?.value,
+    };
+}
+function normalizePerspectiveOutput(raw) {
+    const output = normalizeCapabilityOutput("perspective", raw);
+    const descriptors = Object.getOwnPropertyDescriptors(raw);
+    const recordDescriptor = descriptors.record;
+    if (recordDescriptor === undefined || !("value" in recordDescriptor)) {
+        throw new errors_1.PlanInsightError("contract.invalid", "perspective", "Perspective capability must return a hooks-core PlanPerspectiveRecord");
+    }
+    const record = recordDescriptor.value;
+    if (typeof record !== "object" || record === null || Array.isArray(record)) {
+        throw new errors_1.PlanInsightError("contract.invalid", "perspective", "Perspective capability record must be an object");
+    }
+    return { ...output, record: record };
+}
+function artifact(kind, prepared, output) {
+    return {
+        id: prepared.artifactIds[kind],
+        kind,
+        value: output.value,
+        externalId: output.externalId,
+        provenance: output.provenance,
+    };
+}
+function validatePerspectiveOutput(output, input) {
+    if (!output || !output.record) {
+        throw new errors_1.PlanInsightError("contract.invalid", "perspective", "Perspective capability must return a hooks-core PlanPerspectiveRecord");
+    }
+    if (output.record.session_id !== input.provenance.source_session_id) {
+        throw new errors_1.PlanInsightError("contract.invalid", "perspective", "Perspective record session_id does not match request provenance", {
+            details: {
+                expected: input.provenance.source_session_id,
+                actual: output.record.session_id,
+            },
+        });
+    }
+    if (output.record.latest_plan_path !== input.provenance.plan_path) {
+        throw new errors_1.PlanInsightError("contract.invalid", "perspective", "Perspective record latest_plan_path does not match request provenance", {
+            details: {
+                expected: input.provenance.plan_path,
+                actual: output.record.latest_plan_path,
+            },
+        });
+    }
+}
+async function runPlanInsight(input, capabilities) {
+    const prepared = (0, prepare_1.preparePlanInsight)(input);
+    const complete = resolveCapabilities(capabilities);
+    const canonicalInput = structuredClone(input);
+    const baseContext = () => ({
+        input: structuredClone(canonicalInput),
+        prepared: structuredClone(prepared),
+    });
+    const rawPerspectiveOutput = await executeCapability("perspective", () => complete.perspective(baseContext()));
+    const perspectiveOutput = normalizePerspectiveOutput(rawPerspectiveOutput);
+    validatePerspectiveOutput(perspectiveOutput, canonicalInput);
+    const perspective = artifact("perspective", prepared, perspectiveOutput);
+    const rawChartOutput = await executeCapability("chart", () => complete.chart({ ...baseContext(), perspective }));
+    const chartOutput = normalizeCapabilityOutput("chart", rawChartOutput);
+    const chart = artifact("chart", prepared, chartOutput);
+    const rawTraceOutput = await executeCapability("trace", () => complete.trace({ ...baseContext(), perspective, chart }));
+    const traceOutput = normalizeCapabilityOutput("trace", rawTraceOutput);
+    const trace = artifact("trace", prepared, traceOutput);
+    const rawMemoryOutput = await executeCapability("memory", () => complete.memory({ ...baseContext(), perspective, chart, trace }));
+    const memoryOutput = normalizeCapabilityOutput("memory", rawMemoryOutput);
+    const memory = artifact("memory", prepared, memoryOutput);
+    const perspectiveReadyEvent = (0, hooks_core_1.perspectiveReadyEventFromRecord)(perspectiveOutput.record, {
+        episode_key: canonicalInput.episodeKey,
+        source: { ...canonicalInput.source },
+        plan_pane_id: canonicalInput.provenance.plan_pane_id,
+        event_id: `evt_plan_insight_${prepared.idempotencyKey.slice(0, 24)}`,
+        occurred_at: canonicalInput.capturedAt,
+    });
+    const validation = (0, hooks_core_1.validatePlanReviewEvent)(perspectiveReadyEvent);
+    if (!validation.valid) {
+        throw new errors_1.PlanInsightError("contract.invalid", "contract", "hooks-core rejected the perspective-ready event", { details: { errors: validation.errors } });
+    }
+    return {
+        runId: prepared.runId,
+        idempotencyKey: prepared.idempotencyKey,
+        provenance: { ...prepared.provenance },
+        perspective,
+        chart,
+        trace,
+        memory,
+        perspectiveReadyEvent,
+        perspectiveReadyIdempotencyKey: (0, hooks_core_1.planReviewIdempotencyKey)(perspectiveReadyEvent),
+    };
+}

package/dist/prepare.d.ts

@@ -0,0 +1,2 @@
+import type { PlanInsightInput, PreparedPlanInsight } from "./types";
+export declare function preparePlanInsight(input: PlanInsightInput): PreparedPlanInsight;

package/dist/prepare.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preparePlanInsight = preparePlanInsight;
+const hooks_core_1 = require("@miadi/hooks-core");
+const errors_1 = require("./errors");
+function requireText(value, field) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new errors_1.PlanInsightError("request.invalid", "request", `${field} must be a non-empty string`, { details: { field } });
+    }
+}
+function copyProvenance(provenance) {
+    return { ...provenance };
+}
+function preparePlanInsight(input) {
+    requireText(input.episodeKey, "episodeKey");
+    requireText(input.planContent, "planContent");
+    requireText(input.planFilename, "planFilename");
+    requireText(input.source?.system, "source.system");
+    requireText(input.provenance?.source_session_id, "provenance.source_session_id");
+    requireText(input.provenance?.trace_id, "provenance.trace_id");
+    requireText(input.provenance?.plan_pane_id, "provenance.plan_pane_id");
+    requireText(input.provenance?.plan_path, "provenance.plan_path");
+    if (!input.capturedAt || Number.isNaN(Date.parse(input.capturedAt))) {
+        throw new errors_1.PlanInsightError("request.invalid", "request", "capturedAt must be a parseable date-time", { details: { field: "capturedAt" } });
+    }
+    const provenance = copyProvenance(input.provenance);
+    const idempotencyKey = (0, hooks_core_1.deriveIdempotencyKey)({
+        sessionId: provenance.source_session_id,
+        agent: input.source.agent ?? input.source.system,
+        nativeEvent: "plan-insight.run",
+        payload: {
+            episode_key: input.episodeKey,
+            plan_content: input.planContent,
+            plan_filename: input.planFilename,
+            provenance,
+            source: { ...input.source },
+        },
+    });
+    const runId = `plan-insight:${idempotencyKey}`;
+    return {
+        runId,
+        idempotencyKey,
+        artifactIds: {
+            perspective: `${runId}:perspective`,
+            chart: `${runId}:chart`,
+            trace: `${runId}:trace`,
+            memory: `${runId}:memory`,
+        },
+        provenance,
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,88 @@
+import type { EpisodicMemory } from "@miadi/episodic-memory-schema";
+import type { PlanPerspectiveRecord, PlanProvenance, PlanReviewEventEnvelope, PlanReviewSource, PlanReviewValidation } from "@miadi/hooks-core";
+export type PlanInsightProvenance = PlanProvenance & {
+    source_session_id: string;
+    trace_id: string;
+    plan_pane_id: string;
+    plan_path: string;
+};
+export interface PlanInsightInput {
+    episodeKey: string;
+    planContent: string;
+    planFilename: string;
+    source: PlanReviewSource;
+    provenance: PlanInsightProvenance;
+    /** Caller-supplied timestamp; the package does not invent execution time. */
+    capturedAt: string;
+}
+export type PlanInsightArtifactIds = {
+    perspective: string;
+    chart: string;
+    trace: string;
+    memory: string;
+};
+export interface PreparedPlanInsight {
+    runId: string;
+    idempotencyKey: string;
+    artifactIds: PlanInsightArtifactIds;
+    provenance: PlanInsightProvenance;
+}
+export type PlanInsightCapabilityName = "perspective" | "chart" | "trace" | "memory";
+export interface CapabilityOutput<T> {
+    value: T;
+    /** Real provider/service reference, when one exists. */
+    externalId?: string;
+    provenance?: Record<string, unknown>;
+}
+export interface PerspectiveCapabilityOutput<T> extends CapabilityOutput<T> {
+    record: PlanPerspectiveRecord;
+}
+export interface PlanInsightArtifact<T> extends CapabilityOutput<T> {
+    id: string;
+    kind: PlanInsightCapabilityName;
+}
+export interface PlanInsightBaseContext {
+    input: PlanInsightInput;
+    prepared: PreparedPlanInsight;
+}
+export type PerspectiveCapability<T> = (context: PlanInsightBaseContext) => Promise<PerspectiveCapabilityOutput<T>>;
+export type ChartCapability<P, C> = (context: PlanInsightBaseContext & {
+    perspective: PlanInsightArtifact<P>;
+}) => Promise<CapabilityOutput<C>>;
+export type TraceCapability<P, C, T> = (context: PlanInsightBaseContext & {
+    perspective: PlanInsightArtifact<P>;
+    chart: PlanInsightArtifact<C>;
+}) => Promise<CapabilityOutput<T>>;
+export type MemoryCapability<P, C, T> = (context: PlanInsightBaseContext & {
+    perspective: PlanInsightArtifact<P>;
+    chart: PlanInsightArtifact<C>;
+    trace: PlanInsightArtifact<T>;
+}) => Promise<CapabilityOutput<EpisodicMemory>>;
+export interface PlanInsightCapabilities<P = unknown, C = unknown, T = unknown> {
+    perspective: PerspectiveCapability<P>;
+    chart: ChartCapability<P, C>;
+    trace: TraceCapability<P, C, T>;
+    memory: MemoryCapability<P, C, T>;
+}
+export interface DiscoverPlanInsightPerspectivesOptions {
+    episodeKey: string;
+    source: PlanReviewSource;
+    planPaneId?: string;
+}
+export interface DiscoveredPlanInsightPerspective {
+    record: PlanPerspectiveRecord;
+    event: PlanReviewEventEnvelope;
+    validation: PlanReviewValidation;
+    idempotencyKey: string;
+}
+export interface PlanInsightResult<P = unknown, C = unknown, T = unknown> {
+    runId: string;
+    idempotencyKey: string;
+    provenance: PlanInsightProvenance;
+    perspective: PlanInsightArtifact<P>;
+    chart: PlanInsightArtifact<C>;
+    trace: PlanInsightArtifact<T>;
+    memory: PlanInsightArtifact<EpisodicMemory>;
+    perspectiveReadyEvent: PlanReviewEventEnvelope;
+    perspectiveReadyIdempotencyKey: string;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@miadi/plan-insight",
+  "version": "0.1.0",
+  "description": "Capability-injected orchestration for turning a plan into a validated perspective, chart, trace, and episodic-memory result.",
+  "license": "MIT",
+  "author": "Miadi",
+  "homepage": "https://github.com/jgwill/Miadi/tree/main/packages/plan-insight",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jgwill/Miadi.git",
+    "directory": "packages/plan-insight"
+  },
+  "type": "commonjs",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "type-check": "tsc -p tsconfig.build.json --noEmit",
+    "test": "d=$(mktemp -d \"${TMPDIR:-/tmp}/miadi-plan-insight-test.XXXXXX\") && trap 'rm -rf \"$d\"' EXIT && tsc -p tsconfig.test.json --outDir \"$d\" && NODE_PATH=\"$PWD/node_modules\" node --test \"$d\"/test/*.test.js",
+    "prepublishOnly": "npm test && npm run build"
+  },
+  "dependencies": {
+    "@miadi/episodic-memory-schema": "0.2.0",
+    "@miadi/hooks-core": "0.4.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.4.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}