@kya-os/cli 2.0.0 → 2.0.3

package/node_modules/@kya-os/contracts/dist/workbench/tracking.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrackingDecompositionDraftSchema = exports.TrackingDecompositionProposalSchema = exports.TrackingLeadChildProposalSchema = exports.TrackingReimportDraftSchema = exports.TrackingImportConflictSchema = exports.TrackingReadinessSchema = exports.TrackingReadinessReasonCodeSchema = exports.TrackingReadinessContextSchema = exports.AcceptedArtifactSchema = exports.TrackingImportDraftSchema = exports.TrackDocumentSchema = exports.TrackingImportIssueSchema = exports.TrackingDependencyV1Schema = exports.TrackingDependencySchema = exports.TrackingTaskSpecSchema = exports.TrackerManifestSchema = exports.TrackerManifestTaskV2Schema = exports.TrackerManifestTaskSchema = exports.TrackerManifestDependencySchema = exports.TrackingDependencyRequirementSchema = exports.TrackingArtifactRequirementSchema = exports.TrackingArtifactKindSchema = exports.EvidenceClaimSchema = exports.TrackingRepositoryRefSchema = exports.TrackingAcceptanceCriterionSchema = exports.TrackingExecutionStateSchema = exports.ReportedStateSchema = exports.ReportedDispositionSchema = exports.TrackingSourceSchema = exports.TrackingImportFormatSchema = exports.TRACK_DOCUMENT_SCHEMA_VERSION = exports.TRACK_MANIFEST_VERSIONS = void 0;
+exports.classifyReportedStatus = classifyReportedStatus;
+exports.upgradeStoredTrackerJson = upgradeStoredTrackerJson;
+exports.parseStoredTrackDocument = parseStoredTrackDocument;
+const zod_1 = require("zod");
+const graph_interfaces_js_1 = require("./graph-interfaces.js");
+/** Documents are untrusted claims. These schemas never confer execution authority. */
+/** Portable source manifests: v1 lists prerequisite IDs; v2 may also request a stricter `merged` prerequisite (I1 decision D3). */
+exports.TRACK_MANIFEST_VERSIONS = [1, 2];
+/** Stored tracker documents: v2 edges carry an explicit requirement and origin. A v1 document is upgraded explicitly (`parseStoredTrackDocument`). */
+exports.TRACK_DOCUMENT_SCHEMA_VERSION = 2;
+const StableKeySchema = zod_1.z.string().min(1).max(128).regex(/^[A-Za-z0-9_.-]+$/).refine((s) => s !== '.' && s !== '..');
+const Sha256Schema = zod_1.z.string().regex(/^[0-9a-fA-F]{64}$/);
+const TitleSchema = zod_1.z.string().trim().min(1).max(4096);
+const ClaimUriSchema = zod_1.z.string().min(1).refine((uri) => {
+    try {
+        const parsed = new URL(uri);
+        return ['https:', 'http:'].includes(parsed.protocol) && !parsed.username && !parsed.password;
+    }
+    catch {
+        return !uri.includes(':') && !uri.includes('\0') && !uri.startsWith('//');
+    }
+}, 'Evidence must be an HTTP(S) or inert relative reference');
+exports.TrackingImportFormatSchema = zod_1.z.enum(['json', 'markdown', 'html']);
+exports.TrackingSourceSchema = zod_1.z.object({
+    kind: exports.TrackingImportFormatSchema,
+    locator: zod_1.z.string().min(1),
+    revisionDigest: Sha256Schema,
+    parserVersion: zod_1.z.string().min(1),
+}).strict();
+exports.ReportedDispositionSchema = zod_1.z.enum(['completion_claim', 'pending', 'blocked', 'unknown']);
+function classifyReportedStatus(raw) {
+    const status = raw.trim().toLowerCase();
+    if (['done', 'complete', 'completed', 'implemented', 'merged'].includes(status))
+        return 'completion_claim';
+    if (['wait', 'waiting', 'pending', 'todo', 'open', 'planned'].includes(status))
+        return 'pending';
+    return status === 'blocked' ? 'blocked' : 'unknown';
+}
+exports.ReportedStateSchema = zod_1.z.object({ rawValue: zod_1.z.string(), disposition: exports.ReportedDispositionSchema }).strict()
+    .refine((value) => value.disposition === classifyReportedStatus(value.rawValue), 'Reported disposition must match the source claim');
+exports.TrackingExecutionStateSchema = zod_1.z.enum(['draft', 'needs_reconciliation', 'needs_verification', 'queued', 'running', 'succeeded', 'failed', 'cancelled']);
+exports.TrackingAcceptanceCriterionSchema = zod_1.z.object({ id: StableKeySchema, text: zod_1.z.string().trim().min(1) }).strict();
+exports.TrackingRepositoryRefSchema = zod_1.z.object({ repositoryId: zod_1.z.string().trim().min(1), baseRef: zod_1.z.string().nullable().optional() }).strict();
+exports.EvidenceClaimSchema = zod_1.z.object({ uri: ClaimUriSchema, label: zod_1.z.string().nullable().optional() }).strict();
+exports.TrackingArtifactKindSchema = zod_1.z.enum(['commit', 'pull_request', 'test_report', 'package', 'document', 'workspace_snapshot']);
+exports.TrackingArtifactRequirementSchema = zod_1.z.object({ kind: exports.TrackingArtifactKindSchema, repositoryId: zod_1.z.string().nullable().optional() }).strict();
+exports.TrackingDependencyRequirementSchema = zod_1.z.enum(['accepted_patch', 'merged']);
+/** A v2 source prerequisite: an ID means the exact accepted output; an object may require a merge. */
+exports.TrackerManifestDependencySchema = zod_1.z.union([
+    StableKeySchema,
+    zod_1.z.object({ id: StableKeySchema, requirement: exports.TrackingDependencyRequirementSchema }).strict(),
+]);
+const manifestTask = (dependency) => zod_1.z.object({
+    id: StableKeySchema,
+    title: TitleSchema,
+    objective: zod_1.z.string().max(131072).default(''),
+    wave: zod_1.z.string().nullable().optional(),
+    reportedStatus: zod_1.z.string().default(''),
+    dependsOn: zod_1.z.array(dependency).default([]),
+    acceptanceCriteria: zod_1.z.array(exports.TrackingAcceptanceCriterionSchema).default([]),
+    repositoryRefs: zod_1.z.array(exports.TrackingRepositoryRefSchema).default([]),
+    requiredArtifacts: zod_1.z.array(exports.TrackingArtifactRequirementSchema).default([]),
+    evidenceClaims: zod_1.z.array(exports.EvidenceClaimSchema).default([]),
+}).strict();
+exports.TrackerManifestTaskSchema = manifestTask(StableKeySchema);
+exports.TrackerManifestTaskV2Schema = manifestTask(exports.TrackerManifestDependencySchema);
+/** `duplicates`: a manifest may repeat an identical prerequisite; a stored document may not repeat an edge. */
+function validateGraph(ids, dependencies, ctx, duplicates = 'identical') {
+    const unique = new Set(ids);
+    if (unique.size !== ids.length)
+        ctx.addIssue({ code: zod_1.z.ZodIssueCode.custom, message: 'Duplicate task ID', path: ['tasks'] });
+    const indegrees = new Map([...unique].map((id) => [id, 0]));
+    const outgoing = new Map();
+    const edges = new Set();
+    const requirements = new Map();
+    for (const edge of dependencies) {
+        if (!unique.has(edge.prerequisiteTaskId) || !unique.has(edge.dependentTaskId)) {
+            ctx.addIssue({ code: zod_1.z.ZodIssueCode.custom, message: 'Missing dependency task', path: ['dependencies'] });
+            continue;
+        }
+        const key = JSON.stringify([edge.prerequisiteTaskId, edge.dependentTaskId]);
+        const requirement = edge.requirement ?? 'accepted_patch';
+        if (edges.has(key)) {
+            if (duplicates === 'none' || requirements.get(key) !== requirement)
+                ctx.addIssue({ code: zod_1.z.ZodIssueCode.custom, message: 'Duplicate dependency', path: ['dependencies'] });
+            continue;
+        }
+        edges.add(key);
+        requirements.set(key, requirement);
+        indegrees.set(edge.dependentTaskId, (indegrees.get(edge.dependentTaskId) ?? 0) + 1);
+        outgoing.set(edge.prerequisiteTaskId, [...(outgoing.get(edge.prerequisiteTaskId) ?? []), edge.dependentTaskId]);
+    }
+    const queue = [...indegrees].filter(([, count]) => count === 0).map(([id]) => id);
+    let visited = 0;
+    for (let position = 0; position < queue.length; position += 1) {
+        visited += 1;
+        for (const dependent of outgoing.get(queue[position]) ?? []) {
+            const count = (indegrees.get(dependent) ?? 0) - 1;
+            indegrees.set(dependent, count);
+            if (count === 0)
+                queue.push(dependent);
+        }
+    }
+    if (visited !== unique.size)
+        ctx.addIssue({ code: zod_1.z.ZodIssueCode.custom, message: 'Dependency cycle', path: ['dependencies'] });
+}
+function validateCollections(task, index, ctx) {
+    if (new Set(task.acceptanceCriteria.map((c) => c.id)).size !== task.acceptanceCriteria.length) {
+        ctx.addIssue({ code: zod_1.z.ZodIssueCode.custom, message: 'Duplicate acceptance criterion', path: ['tasks', index, 'acceptanceCriteria'] });
+    }
+    const repositories = new Set(task.repositoryRefs.map((r) => r.repositoryId));
+    if (repositories.size !== task.repositoryRefs.length)
+        ctx.addIssue({ code: zod_1.z.ZodIssueCode.custom, message: 'Duplicate repository', path: ['tasks', index, 'repositoryRefs'] });
+    for (const artifact of task.requiredArtifacts) {
+        if (artifact.repositoryId != null && !repositories.has(artifact.repositoryId))
+            ctx.addIssue({ code: zod_1.z.ZodIssueCode.custom, message: 'Unmapped artifact repository', path: ['tasks', index, 'requiredArtifacts'] });
+    }
+}
+/** Portable file format for JSON and fenced Markdown / inert embedded HTML. A v1 reader never widens to v2 syntax. */
+exports.TrackerManifestSchema = zod_1.z.discriminatedUnion('schemaVersion', [
+    zod_1.z.object({ schemaVersion: zod_1.z.literal(1), title: zod_1.z.string(), tasks: zod_1.z.array(exports.TrackerManifestTaskSchema).min(1).max(2000) }).strict(),
+    zod_1.z.object({ schemaVersion: zod_1.z.literal(2), title: zod_1.z.string(), tasks: zod_1.z.array(exports.TrackerManifestTaskV2Schema).min(1).max(2000) }).strict(),
+]).superRefine((value, ctx) => {
+    const edges = value.tasks.flatMap((t) => t.dependsOn.map((d) => typeof d === 'string' ? { prerequisiteTaskId: d, dependentTaskId: t.id } : { prerequisiteTaskId: d.id, dependentTaskId: t.id, requirement: d.requirement }));
+    validateGraph(value.tasks.map((t) => t.id), edges, ctx);
+    value.tasks.forEach((task, index) => validateCollections(task, index, ctx));
+});
+exports.TrackingTaskSpecSchema = zod_1.z.object({
+    id: zod_1.z.string().min(1), sourceItemId: StableKeySchema, sourceAnchor: zod_1.z.string(), revision: zod_1.z.number().int().positive(),
+    title: TitleSchema, objective: zod_1.z.string().max(131072), group: zod_1.z.string().nullable(),
+    reportedState: exports.ReportedStateSchema,
+    acceptanceCriteria: zod_1.z.array(exports.TrackingAcceptanceCriterionSchema),
+    repositoryRefs: zod_1.z.array(exports.TrackingRepositoryRefSchema),
+    requiredArtifacts: zod_1.z.array(exports.TrackingArtifactRequirementSchema), evidenceClaims: zod_1.z.array(exports.EvidenceClaimSchema),
+}).strict();
+/** A stored edge is the frozen I1 edge record: requirement plus provenance, which never grants authority. */
+exports.TrackingDependencySchema = graph_interfaces_js_1.TrackDependencyV2Schema;
+/** Stored edges written before document v2: task IDs only. Read through `upgradeStoredTrackerJson`. */
+exports.TrackingDependencyV1Schema = zod_1.z.object({ prerequisiteTaskId: zod_1.z.string().min(1), dependentTaskId: zod_1.z.string().min(1) }).strict();
+exports.TrackingImportIssueSchema = zod_1.z.object({ taskId: zod_1.z.string().nullable(), code: zod_1.z.string(), message: zod_1.z.string() }).strict();
+exports.TrackDocumentSchema = zod_1.z.object({
+    schemaVersion: zod_1.z.literal(exports.TRACK_DOCUMENT_SCHEMA_VERSION), id: StableKeySchema, title: zod_1.z.string(), source: exports.TrackingSourceSchema,
+    tasks: zod_1.z.array(exports.TrackingTaskSpecSchema).min(1).max(2000), dependencies: zod_1.z.array(exports.TrackingDependencySchema), unresolved: zod_1.z.array(exports.TrackingImportIssueSchema),
+}).strict().superRefine((value, ctx) => {
+    value.tasks.forEach((task, index) => {
+        if (task.id !== `${value.id}/${task.sourceItemId}`)
+            ctx.addIssue({ code: zod_1.z.ZodIssueCode.custom, message: 'Task identity is outside its tracker', path: ['tasks', index, 'id'] });
+        validateCollections(task, index, ctx);
+    });
+    validateGraph(value.tasks.map((t) => t.id), value.dependencies, ctx, 'none');
+});
+const V1_DOCUMENT_KEYS = ['schemaVersion', 'id', 'title', 'source', 'tasks', 'dependencies', 'unresolved'];
+/**
+ * Explicit one-way upgrade of stored tracker JSON written before document v2, mirroring Rust
+ * `tracking::upgrade_stored_json`: a v1 document becomes v2 and each v1 edge (only its two task IDs)
+ * becomes `accepted_patch` with `source` provenance. Current data is unchanged. Use it only for
+ * stored records; imported sources keep their own strict versions.
+ */
+function upgradeStoredTrackerJson(value) {
+    if (Array.isArray(value))
+        return value.map(upgradeStoredTrackerJson);
+    if (value === null || typeof value !== 'object')
+        return value;
+    const entries = Object.entries(value).map(([key, nested]) => [key, upgradeStoredTrackerJson(nested)]);
+    const upgraded = Object.fromEntries(entries);
+    const keys = Object.keys(upgraded);
+    if (keys.length === 2 && 'prerequisiteTaskId' in upgraded && 'dependentTaskId' in upgraded) {
+        upgraded.requirement = 'accepted_patch';
+        upgraded.origin = 'source';
+    }
+    if (keys.length === V1_DOCUMENT_KEYS.length && V1_DOCUMENT_KEYS.every((key) => key in upgraded) && upgraded.schemaVersion === 1) {
+        upgraded.schemaVersion = exports.TRACK_DOCUMENT_SCHEMA_VERSION;
+    }
+    return upgraded;
+}
+/** Reads a stored tracker document of any implemented version as document v2. */
+function parseStoredTrackDocument(input) {
+    return exports.TrackDocumentSchema.parse(upgradeStoredTrackerJson(input));
+}
+exports.TrackingImportDraftSchema = zod_1.z.object({ track: exports.TrackDocumentSchema, manifestReferences: zod_1.z.array(zod_1.z.string()) }).strict();
+/** Only the verified acceptance store supplies this value, never an imported link. */
+exports.AcceptedArtifactSchema = zod_1.z.object({
+    taskId: zod_1.z.string().min(1), specRevision: zod_1.z.number().int().positive(), kind: exports.TrackingArtifactKindSchema,
+    reference: zod_1.z.string().trim().min(1), digest: Sha256Schema, repositoryId: zod_1.z.string().nullable(),
+}).strict();
+exports.TrackingReadinessContextSchema = zod_1.z.object({
+    state: exports.TrackingExecutionStateSchema, approvedRevision: zod_1.z.number().int().positive().nullable(), authorityReady: zod_1.z.boolean(), repositoriesReady: zod_1.z.boolean(),
+    externalBlockers: zod_1.z.array(zod_1.z.string()), acceptedArtifacts: zod_1.z.array(exports.AcceptedArtifactSchema),
+}).strict();
+/** Why an item may not start. Frozen with Rust `ReadinessCode`: a new code is a contract change. */
+exports.TrackingReadinessReasonCodeSchema = zod_1.z.enum([
+    'invalid_track', 'unknown_task', 'completion_claim_requires_verification', 'source_needs_reconciliation',
+    'not_queued', 'unapproved_revision', 'missing_acceptance_criteria', 'repositories_not_ready',
+    'authority_not_ready', 'external_blocker', 'blocking_issue_unresolved', 'dependency_artifact_invalid',
+    'dependency_artifact_ambiguous', 'dependency_artifact_missing', 'dependency_requires_merge',
+    'dependency_binding_missing', 'dependency_binding_stale',
+]);
+exports.TrackingReadinessSchema = zod_1.z.object({ startable: zod_1.z.boolean(), reasons: zod_1.z.array(zod_1.z.object({ code: exports.TrackingReadinessReasonCodeSchema, message: zod_1.z.string() }).strict()) }).strict();
+exports.TrackingImportConflictSchema = zod_1.z.object({ taskId: zod_1.z.string().nullable(), field: zod_1.z.string(), base: zod_1.z.unknown(), local: zod_1.z.unknown(), incoming: zod_1.z.unknown() }).strict();
+exports.TrackingReimportDraftSchema = zod_1.z.object({
+    unchanged: zod_1.z.boolean(), proposed: exports.TrackDocumentSchema, conflicts: zod_1.z.array(exports.TrackingImportConflictSchema), pendingRunning: zod_1.z.array(exports.TrackingTaskSpecSchema),
+    pendingDependencies: zod_1.z.array(exports.TrackingDependencySchema).nullable(), missingTaskIds: zod_1.z.array(zod_1.z.string()), invalidatedAcceptance: zod_1.z.array(zod_1.z.string()),
+}).strict();
+exports.TrackingLeadChildProposalSchema = zod_1.z.object({
+    role: zod_1.z.string().min(1).max(64).regex(/^[a-z][a-z0-9_-]*$/), title: TitleSchema, objective: zod_1.z.string().trim().min(1),
+    repositoryRef: exports.TrackingRepositoryRefSchema, acceptanceCriteria: zod_1.z.array(exports.TrackingAcceptanceCriterionSchema).min(1),
+    coversParentCriteria: zod_1.z.array(StableKeySchema), dependsOnRoles: zod_1.z.array(zod_1.z.string().min(1)),
+}).strict();
+exports.TrackingDecompositionProposalSchema = zod_1.z.object({
+    schemaVersion: zod_1.z.literal(1), parentTaskId: zod_1.z.string().min(1), parentSpecRevision: zod_1.z.number().int().positive(),
+    parentOnlyCriteria: zod_1.z.array(StableKeySchema), children: zod_1.z.array(exports.TrackingLeadChildProposalSchema).min(1).max(100),
+}).strict().superRefine((value, ctx) => {
+    validateGraph(value.children.map((c) => c.role), value.children.flatMap((c) => c.dependsOnRoles.map((role) => ({ prerequisiteTaskId: role, dependentTaskId: c.role }))), ctx);
+});
+exports.TrackingDecompositionDraftSchema = zod_1.z.object({
+    proposedRemovals: zod_1.z.array(zod_1.z.string()).default([]),
+    parentTaskId: zod_1.z.string().min(1), parentSpecRevision: zod_1.z.number().int().positive(), childTaskIds: zod_1.z.array(zod_1.z.string().min(1)), proposed: exports.TrackDocumentSchema,
+}).strict();

package/node_modules/@kya-os/contracts/dist/workbench/usage.d.ts

@@ -0,0 +1,62 @@
+import { z } from "zod";
+export declare const UsageBasisSchema: z.ZodEnum<["request_delta", "turn_delta", "session_total", "unknown"]>;
+export declare const InputTokenSemanticsSchema: z.ZodEnum<["includes_cache", "excludes_cache", "unknown"]>;
+/** Native reported token counts. These are neither invoice amounts nor estimates.
+ * A session_total must not be attributed to a resumed attempt without a baseline.
+ * Missing remains null; complete describes telemetry coverage, not task quality. */
+export declare const AttemptUsageSchema: z.ZodEffects<z.ZodObject<{
+    inputTokens: z.ZodNullable<z.ZodNumber>;
+    outputTokens: z.ZodNullable<z.ZodNumber>;
+    cacheReadTokens: z.ZodNullable<z.ZodNumber>;
+    cacheWriteTokens: z.ZodNullable<z.ZodNumber>;
+    basis: z.ZodEnum<["request_delta", "turn_delta", "session_total", "unknown"]>;
+    inputSemantics: z.ZodEnum<["includes_cache", "excludes_cache", "unknown"]>;
+    complete: z.ZodBoolean;
+    observedEvents: z.ZodNumber;
+    source: z.ZodEnum<["native_runtime", "unknown"]>;
+}, "strict", z.ZodTypeAny, {
+    complete: boolean;
+    source: "unknown" | "native_runtime";
+    inputTokens: number | null;
+    outputTokens: number | null;
+    cacheReadTokens: number | null;
+    cacheWriteTokens: number | null;
+    basis: "unknown" | "request_delta" | "turn_delta" | "session_total";
+    inputSemantics: "unknown" | "excludes_cache" | "includes_cache";
+    observedEvents: number;
+}, {
+    complete: boolean;
+    source: "unknown" | "native_runtime";
+    inputTokens: number | null;
+    outputTokens: number | null;
+    cacheReadTokens: number | null;
+    cacheWriteTokens: number | null;
+    basis: "unknown" | "request_delta" | "turn_delta" | "session_total";
+    inputSemantics: "unknown" | "excludes_cache" | "includes_cache";
+    observedEvents: number;
+}>, {
+    complete: boolean;
+    source: "unknown" | "native_runtime";
+    inputTokens: number | null;
+    outputTokens: number | null;
+    cacheReadTokens: number | null;
+    cacheWriteTokens: number | null;
+    basis: "unknown" | "request_delta" | "turn_delta" | "session_total";
+    inputSemantics: "unknown" | "excludes_cache" | "includes_cache";
+    observedEvents: number;
+}, {
+    complete: boolean;
+    source: "unknown" | "native_runtime";
+    inputTokens: number | null;
+    outputTokens: number | null;
+    cacheReadTokens: number | null;
+    cacheWriteTokens: number | null;
+    basis: "unknown" | "request_delta" | "turn_delta" | "session_total";
+    inputSemantics: "unknown" | "excludes_cache" | "includes_cache";
+    observedEvents: number;
+}>;
+export type AttemptUsage = z.infer<typeof AttemptUsageSchema>;
+export type UsageBasis = z.infer<typeof UsageBasisSchema>;
+export type InputTokenSemantics = z.infer<typeof InputTokenSemanticsSchema>;
+export declare const HeadlessAttemptStatusSchema: z.ZodEnum<["succeeded", "failed", "timed_out", "spawn_failed", "rejected"]>;
+export type HeadlessAttemptStatus = z.infer<typeof HeadlessAttemptStatusSchema>;

package/node_modules/@kya-os/contracts/dist/workbench/usage.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeadlessAttemptStatusSchema = exports.AttemptUsageSchema = exports.InputTokenSemanticsSchema = exports.UsageBasisSchema = void 0;
+const zod_1 = require("zod");
+const observedCount = zod_1.z
+    .number()
+    .int()
+    .nonnegative()
+    .max(Number.MAX_SAFE_INTEGER)
+    .nullable();
+exports.UsageBasisSchema = zod_1.z.enum([
+    "request_delta",
+    "turn_delta",
+    "session_total",
+    "unknown",
+]);
+exports.InputTokenSemanticsSchema = zod_1.z.enum([
+    "includes_cache",
+    "excludes_cache",
+    "unknown",
+]);
+/** Native reported token counts. These are neither invoice amounts nor estimates.
+ * A session_total must not be attributed to a resumed attempt without a baseline.
+ * Missing remains null; complete describes telemetry coverage, not task quality. */
+exports.AttemptUsageSchema = zod_1.z
+    .object({
+    inputTokens: observedCount,
+    outputTokens: observedCount,
+    cacheReadTokens: observedCount,
+    cacheWriteTokens: observedCount,
+    basis: exports.UsageBasisSchema,
+    inputSemantics: exports.InputTokenSemanticsSchema,
+    complete: zod_1.z.boolean(),
+    observedEvents: zod_1.z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+    source: zod_1.z.enum(["native_runtime", "unknown"]),
+})
+    .strict()
+    .superRefine((usage, ctx) => {
+    if (usage.complete &&
+        (usage.source !== "native_runtime" ||
+            usage.basis === "unknown" ||
+            usage.basis === "session_total" ||
+            usage.inputTokens === null ||
+            usage.outputTokens === null)) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: "Complete attempt coverage requires observed deltas and both input/output counts",
+        });
+    }
+});
+exports.HeadlessAttemptStatusSchema = zod_1.z.enum([
+    "succeeded",
+    "failed",
+    "timed_out",
+    "spawn_failed",
+    "rejected",
+]);

package/node_modules/@kya-os/contracts/package.json

@@ -0,0 +1,185 @@
+{
+  "name": "@kya-os/contracts",
+  "version": "1.12.4",
+  "description": "Shared contracts, types, and schemas for MCP-I framework",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./consent": {
+      "types": "./dist/consent/index.d.ts",
+      "default": "./dist/consent/index.js"
+    },
+    "./delegation": {
+      "types": "./dist/delegation/index.d.ts",
+      "default": "./dist/delegation/index.js"
+    },
+    "./agentshield-api": {
+      "types": "./dist/agentshield-api/index.d.ts",
+      "default": "./dist/agentshield-api/index.js"
+    },
+    "./runtime": {
+      "types": "./dist/runtime/index.d.ts",
+      "default": "./dist/runtime/index.js"
+    },
+    "./fleet": {
+      "types": "./dist/fleet/index.d.ts",
+      "default": "./dist/fleet/index.js"
+    },
+    "./proof": {
+      "types": "./dist/proof/index.d.ts",
+      "default": "./dist/proof/index.js"
+    },
+    "./review": {
+      "types": "./dist/review/index.d.ts",
+      "default": "./dist/review/index.js"
+    },
+    "./review/verify": {
+      "types": "./dist/review/verify.d.ts",
+      "default": "./dist/review/verify.js"
+    },
+    "./tool-protection": {
+      "types": "./dist/tool-protection/index.d.ts",
+      "default": "./dist/tool-protection/index.js"
+    },
+    "./config": {
+      "types": "./dist/config/index.d.ts",
+      "default": "./dist/config/index.js"
+    },
+    "./dashboard-config": {
+      "types": "./dist/dashboard-config/index.d.ts",
+      "default": "./dist/dashboard-config/index.js"
+    },
+    "./audit": {
+      "types": "./dist/audit/index.d.ts",
+      "default": "./dist/audit/index.js"
+    },
+    "./verifier": {
+      "types": "./dist/verifier/index.d.ts",
+      "default": "./dist/verifier/index.js"
+    },
+    "./handshake": {
+      "types": "./dist/handshake/index.d.ts",
+      "default": "./dist/handshake/index.js"
+    },
+    "./handshake/verify": {
+      "types": "./dist/handshake/verify.d.ts",
+      "default": "./dist/handshake/verify.js"
+    },
+    "./well-known": {
+      "types": "./dist/well-known/index.d.ts",
+      "default": "./dist/well-known/index.js"
+    },
+    "./gateway": {
+      "types": "./dist/gateway/index.d.ts",
+      "default": "./dist/gateway/index.js"
+    },
+    "./cli": {
+      "types": "./dist/cli.d.ts",
+      "default": "./dist/cli.js"
+    },
+    "./test": {
+      "types": "./dist/test.d.ts",
+      "default": "./dist/test.js"
+    },
+    "./registry": {
+      "types": "./dist/registry.d.ts",
+      "default": "./dist/registry.js"
+    },
+    "./identity": {
+      "types": "./dist/identity/index.d.ts",
+      "default": "./dist/identity/index.js"
+    },
+    "./deploy": {
+      "types": "./dist/deploy/index.d.ts",
+      "default": "./dist/deploy/index.js"
+    },
+    "./reputation": {
+      "types": "./dist/reputation/index.d.ts",
+      "default": "./dist/reputation/index.js"
+    },
+    "./policy": {
+      "types": "./dist/policy/index.d.ts",
+      "default": "./dist/policy/index.js"
+    },
+    "./molti": {
+      "types": "./dist/molti/index.d.ts",
+      "default": "./dist/molti/index.js"
+    },
+    "./agent-deployment": {
+      "types": "./dist/agent-deployment.d.ts",
+      "default": "./dist/agent-deployment.js"
+    },
+    "./compute": {
+      "types": "./dist/compute.d.ts",
+      "default": "./dist/compute.js"
+    },
+    "./compute-binding": {
+      "types": "./dist/compute-binding.d.ts",
+      "default": "./dist/compute-binding.js"
+    },
+    "./pairing": {
+      "types": "./dist/pairing/index.d.ts",
+      "default": "./dist/pairing/index.js"
+    },
+    "./vault": {
+      "types": "./dist/vault/index.d.ts",
+      "default": "./dist/vault/index.js"
+    },
+    "./skills": {
+      "types": "./dist/skills/index.d.ts",
+      "default": "./dist/skills/index.js"
+    },
+    "./cli-read": {
+      "types": "./dist/cli-read/index.d.ts",
+      "default": "./dist/cli-read/index.js"
+    },
+    "./attribution": {
+      "types": "./dist/attribution/index.d.ts",
+      "default": "./dist/attribution/index.js"
+    },
+    "./workbench": {
+      "types": "./dist/workbench/index.d.ts",
+      "default": "./dist/workbench/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && npm run emit-schemas && npm run check-exports-integrity",
+    "emit-schemas": "node scripts/emit-schemas.mjs",
+    "check-exports-integrity": "node scripts/check-exports-integrity.mjs",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "test:watch": "vitest",
+    "lint": "eslint .",
+    "format": "prettier --write \"src/**/*.{ts,tsx}\"",
+    "clean": "rm -rf dist .turbo node_modules",
+    "prepublishOnly": "npm run build && node ../create-mcpi-app/scripts/validate-no-workspace.js"
+  },
+  "sideEffects": false,
+  "dependencies": {
+    "@kya-os/consent": "^0.1.23",
+    "zod": "^3.25.67"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.9",
+    "@vitest/coverage-v8": "^4.0.18",
+    "ajv": "^8.18.0",
+    "ajv-formats": "^3.0.1",
+    "eslint": "^9.26.0",
+    "typescript": "^5.5.3",
+    "vitest": "^4.0.18",
+    "zod-to-json-schema": "3.23.5"
+  },
+  "files": [
+    "dist",
+    "parity-vectors",
+    "package.json",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}