@phyzess/pappra 0.0.0-stage → 0.1.0-beta.2

package/dist/schemas/collaboration.js

@@ -0,0 +1,106 @@
+import { z } from 'zod';
+const taskId = z
+    .string()
+    .min(1)
+    .max(128)
+    .regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
+const absolutePath = z
+    .string()
+    .min(1)
+    .max(4096)
+    .refine((value) => value.startsWith('/'), {
+    message: 'path must be absolute',
+});
+const identity = z.strictObject({
+    agent_id: z.string().min(1).max(128),
+    session_id: z.string().min(1).max(256),
+    harness: z.string().min(1).max(64),
+});
+const requirements = z.strictObject({
+    skills: z
+        .array(z.strictObject({
+        id: z.string().min(1),
+        bundle_digest: z.string().min(1),
+    }))
+        .max(16),
+    tools: z.array(z.string().min(1).max(128)).max(32),
+});
+const resource = z.strictObject({
+    path: absolutePath,
+    access: z.enum(['read', 'write']),
+});
+export const collaborationGoalSchema = z.strictObject({
+    schema: z.literal('pappra/collaboration-goal/1'),
+    task_id: taskId,
+    subtask_id: taskId,
+    attempt: z.number().int().min(1).max(1000),
+    phase: z.enum(['discovery', 'implementation', 'review', 'handoff', 'fix']),
+    objective: z.string().min(1).max(4000),
+    acceptance: z.array(z.string().min(1).max(1000)).min(1).max(32),
+    prompt: z.string().min(1).max(20000),
+    coordinator: identity.extend({ owner_epoch: z.number().int().min(1) }),
+    assignee: identity.extend({
+        cwd: absolutePath,
+        surface: z.string().min(1).max(64),
+        configuration_id: z.string().min(1).max(128),
+    }),
+    resources: z.array(resource).min(1).max(32),
+    required: requirements,
+    preferred: requirements.default({ skills: [], tools: [] }),
+});
+export const collaborationPreparedSchema = z.strictObject({
+    schema: z.literal('pappra/collaboration-prepared/1'),
+    task_id: taskId,
+    subtask_id: taskId,
+    attempt: z.number().int().min(1),
+    phase: z.string().min(1).max(32),
+    task_root: absolutePath,
+    domain_root: absolutePath,
+    prepared_dir: absolutePath,
+    assignment_path: absolutePath,
+    prompt_path: absolutePath,
+    goal_path: absolutePath,
+    assignment_digest: z.string().min(1),
+    prompt_digest: z.string().min(1),
+    resource_epochs: z.record(z.string(), z.number().int().min(1)),
+    claim_ids: z.array(z.string().min(1)).max(64),
+    state_revision: z.number().int().min(0),
+    created_at: z.string().min(1),
+});
+export const collaborationCommandSchema = z.discriminatedUnion('action', [
+    z.strictObject({
+        schema: z.literal('pappra/collaboration-command/1'),
+        action: z.literal('query'),
+        request_id: z.string().min(1).max(128),
+    }),
+    z.strictObject({
+        schema: z.literal('pappra/collaboration-command/1'),
+        action: z.literal('cancel'),
+        request_id: z.string().min(1).max(128),
+    }),
+    z.strictObject({
+        schema: z.literal('pappra/collaboration-command/1'),
+        action: z.literal('finish'),
+        request_id: z.string().min(1).max(128),
+        status: z.enum([
+            'completed',
+            'failed',
+            'cancelled',
+            'needs_input',
+            'unknown',
+        ]),
+        outputs: z.array(z.unknown()).max(32).default([]),
+        native_ref: z.unknown().nullable().default(null),
+        evidence_ref: z.string().max(4096).nullable().default(null),
+    }),
+]);
+export const collaborationEventSchema = z.strictObject({
+    schema: z.literal('pappra/collaboration-event/1'),
+    sequence: z.number().int().min(1),
+    request_id: z.string().min(1).max(128).nullable(),
+    kind: z.enum(['started', 'query', 'cancel', 'finished', 'refused', 'report']),
+    at: z.string().min(1),
+    status: z.string().min(1).max(64),
+    detail: z.string().max(4096).nullable(),
+    data: z.unknown().nullable(),
+});

package/dist/schemas/continuity.d.ts

@@ -0,0 +1,315 @@
+import { z } from 'zod';
+export declare const TASK_CONTEXT_SCHEMA = "pappra/task-context/1";
+export declare const CHECKPOINT_SCHEMA = "pappra/checkpoint/1";
+export declare const CHECKPOINT_POINTER_SCHEMA = "pappra/checkpoint-pointer/1";
+export declare const RESUME_PACKET_SCHEMA = "pappra/resume-packet/1";
+export declare const continuityArtifactPathSchema: z.ZodString;
+export declare const taskContextSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/task-context/1">;
+    taskId: z.ZodString;
+    workspaceId: z.ZodUUID;
+    objective: z.ZodString;
+    acceptance: z.ZodArray<z.ZodString>;
+    constraints: z.ZodArray<z.ZodString>;
+    artifacts: z.ZodArray<z.ZodString>;
+    collaborationRecordRef: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type TaskContext = z.infer<typeof taskContextSchema>;
+export declare const checkpointRepositorySchema: z.ZodObject<{
+    repoId: z.ZodString;
+    checkoutId: z.ZodString;
+    root: z.ZodString;
+    head: z.ZodNullable<z.ZodString>;
+    branch: z.ZodNullable<z.ZodString>;
+    dirty: z.ZodNullable<z.ZodBoolean>;
+    patchDigest: z.ZodNullable<z.ZodString>;
+    captureStatus: z.ZodEnum<{
+        complete: "complete";
+        partial: "partial";
+        unknown: "unknown";
+    }>;
+    scope: z.ZodEnum<{
+        external: "external";
+        unknown: "unknown";
+        workspace: "workspace";
+    }>;
+}, z.core.$strict>;
+export declare const checkpointArtifactSchema: z.ZodObject<{
+    path: z.ZodString;
+    digest: z.ZodString;
+    inputVersion: z.ZodNullable<z.ZodString>;
+    observedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export declare const checkpointValidationSchema: z.ZodObject<{
+    id: z.ZodString;
+    result: z.ZodEnum<{
+        failed: "failed";
+        "not-run": "not-run";
+        passed: "passed";
+        unknown: "unknown";
+    }>;
+    inputVersion: z.ZodNullable<z.ZodString>;
+    observedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export declare const checkpointNativeRefSchema: z.ZodObject<{
+    harness: z.ZodEnum<{
+        claude: "claude";
+        codex: "codex";
+        pi: "pi";
+        unknown: "unknown";
+    }>;
+    sessionId: z.ZodNullable<z.ZodString>;
+    turnId: z.ZodNullable<z.ZodString>;
+    runId: z.ZodNullable<z.ZodString>;
+    scope: z.ZodLiteral<"stored-snapshot">;
+    observedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export declare const checkpointSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/checkpoint/1">;
+    checkpointId: z.ZodUUID;
+    taskId: z.ZodString;
+    workspaceId: z.ZodUUID;
+    revision: z.ZodNumber;
+    previousDigest: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodISODateTime;
+    authorSession: z.ZodNullable<z.ZodString>;
+    objective: z.ZodString;
+    acceptance: z.ZodArray<z.ZodString>;
+    constraints: z.ZodArray<z.ZodString>;
+    decisions: z.ZodArray<z.ZodString>;
+    attempted: z.ZodArray<z.ZodString>;
+    nextActions: z.ZodArray<z.ZodString>;
+    limitations: z.ZodArray<z.ZodString>;
+    repositories: z.ZodArray<z.ZodObject<{
+        repoId: z.ZodString;
+        checkoutId: z.ZodString;
+        root: z.ZodString;
+        head: z.ZodNullable<z.ZodString>;
+        branch: z.ZodNullable<z.ZodString>;
+        dirty: z.ZodNullable<z.ZodBoolean>;
+        patchDigest: z.ZodNullable<z.ZodString>;
+        captureStatus: z.ZodEnum<{
+            complete: "complete";
+            partial: "partial";
+            unknown: "unknown";
+        }>;
+        scope: z.ZodEnum<{
+            external: "external";
+            unknown: "unknown";
+            workspace: "workspace";
+        }>;
+    }, z.core.$strict>>;
+    artifacts: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        digest: z.ZodString;
+        inputVersion: z.ZodNullable<z.ZodString>;
+        observedAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    validations: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        result: z.ZodEnum<{
+            failed: "failed";
+            "not-run": "not-run";
+            passed: "passed";
+            unknown: "unknown";
+        }>;
+        inputVersion: z.ZodNullable<z.ZodString>;
+        observedAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    nativeRefs: z.ZodArray<z.ZodObject<{
+        harness: z.ZodEnum<{
+            claude: "claude";
+            codex: "codex";
+            pi: "pi";
+            unknown: "unknown";
+        }>;
+        sessionId: z.ZodNullable<z.ZodString>;
+        turnId: z.ZodNullable<z.ZodString>;
+        runId: z.ZodNullable<z.ZodString>;
+        scope: z.ZodLiteral<"stored-snapshot">;
+        observedAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    collaborationRecordRef: z.ZodNullable<z.ZodString>;
+    contextCompleteness: z.ZodEnum<{
+        complete: "complete";
+        partial: "partial";
+    }>;
+}, z.core.$strict>;
+export type Checkpoint = z.infer<typeof checkpointSchema>;
+export declare const checkpointPointerSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/checkpoint-pointer/1">;
+    taskId: z.ZodString;
+    workspaceId: z.ZodUUID;
+    revision: z.ZodNumber;
+    checkpointRef: z.ZodString;
+    checkpointDigest: z.ZodString;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type CheckpointPointer = z.infer<typeof checkpointPointerSchema>;
+export declare const resumePacketSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/resume-packet/1">;
+    generatedAt: z.ZodISODateTime;
+    taskId: z.ZodString;
+    workspaceId: z.ZodUUID;
+    checkpoint: z.ZodObject<{
+        ref: z.ZodString;
+        digest: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>;
+    identityChecks: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        status: z.ZodEnum<{
+            changed: "changed";
+            ok: "ok";
+            unknown: "unknown";
+        }>;
+        detail: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    codeDrift: z.ZodObject<{
+        status: z.ZodEnum<{
+            changed: "changed";
+            relocated: "relocated";
+            unchanged: "unchanged";
+            unknown: "unknown";
+        }>;
+        repositories: z.ZodArray<z.ZodObject<{
+            repoId: z.ZodString;
+            status: z.ZodEnum<{
+                changed: "changed";
+                missing: "missing";
+                relocated: "relocated";
+                unchanged: "unchanged";
+                unknown: "unknown";
+            }>;
+            storedHead: z.ZodNullable<z.ZodString>;
+            currentHead: z.ZodNullable<z.ZodString>;
+            storedDirty: z.ZodNullable<z.ZodBoolean>;
+            currentDirty: z.ZodNullable<z.ZodBoolean>;
+            storedPatchDigest: z.ZodNullable<z.ZodString>;
+            currentPatchDigest: z.ZodNullable<z.ZodString>;
+            storedCheckoutId: z.ZodString;
+            currentCheckoutId: z.ZodNullable<z.ZodString>;
+            storedCaptureStatus: z.ZodEnum<{
+                complete: "complete";
+                partial: "partial";
+                unknown: "unknown";
+            }>;
+            currentCaptureStatus: z.ZodEnum<{
+                complete: "complete";
+                partial: "partial";
+                unknown: "unknown";
+            }>;
+            patchStatus: z.ZodEnum<{
+                changed: "changed";
+                missing: "missing";
+                "not-applicable": "not-applicable";
+                unchanged: "unchanged";
+                unknown: "unknown";
+                unsafe: "unsafe";
+            }>;
+            patchDetail: z.ZodNullable<z.ZodString>;
+            detail: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    artifactChecks: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        status: z.ZodEnum<{
+            changed: "changed";
+            missing: "missing";
+            unchanged: "unchanged";
+            unknown: "unknown";
+            unsafe: "unsafe";
+        }>;
+        detail: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    executionObservations: z.ZodArray<z.ZodObject<{
+        harness: z.ZodEnum<{
+            claude: "claude";
+            codex: "codex";
+            pi: "pi";
+            unknown: "unknown";
+        }>;
+        sessionId: z.ZodNullable<z.ZodString>;
+        turnId: z.ZodNullable<z.ZodString>;
+        runId: z.ZodNullable<z.ZodString>;
+        scope: z.ZodLiteral<"stored-snapshot">;
+        liveStatus: z.ZodLiteral<"unknown">;
+        observedAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    collaborationObservation: z.ZodObject<{
+        ref: z.ZodNullable<z.ZodString>;
+        status: z.ZodEnum<{
+            missing: "missing";
+            "not-referenced": "not-referenced";
+            read: "read";
+            unreadable: "unreadable";
+            unsupported: "unsupported";
+        }>;
+        digest: z.ZodNullable<z.ZodString>;
+        authority: z.ZodObject<{
+            valid: z.ZodBoolean;
+            stateRevision: z.ZodNullable<z.ZodNumber>;
+            ownerEpoch: z.ZodNullable<z.ZodNumber>;
+            dispatchFrozen: z.ZodNullable<z.ZodBoolean>;
+            activeAttempts: z.ZodNullable<z.ZodNumber>;
+            unreleasedClaims: z.ZodNullable<z.ZodNumber>;
+            unresolvedUncertainty: z.ZodNullable<z.ZodNumber>;
+            pendingApprovals: z.ZodNullable<z.ZodNumber>;
+            blockerCodes: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        scope: z.ZodLiteral<"persisted-history">;
+        liveStatus: z.ZodLiteral<"unknown">;
+    }, z.core.$strict>;
+    blockingReasons: z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strict>>;
+    executionAllowed: z.ZodBoolean;
+    contextCompleteness: z.ZodEnum<{
+        complete: "complete";
+        partial: "partial";
+    }>;
+    verificationStatus: z.ZodEnum<{
+        current: "current";
+        stale: "stale";
+        unknown: "unknown";
+    }>;
+    boundedContext: z.ZodObject<{
+        objective: z.ZodString;
+        acceptance: z.ZodArray<z.ZodString>;
+        constraints: z.ZodArray<z.ZodString>;
+        decisions: z.ZodArray<z.ZodString>;
+        attempted: z.ZodArray<z.ZodString>;
+        nextActions: z.ZodArray<z.ZodString>;
+        limitations: z.ZodArray<z.ZodString>;
+        repositories: z.ZodArray<z.ZodObject<{
+            repoId: z.ZodString;
+            checkoutId: z.ZodString;
+            root: z.ZodString;
+            head: z.ZodNullable<z.ZodString>;
+            branch: z.ZodNullable<z.ZodString>;
+            dirty: z.ZodNullable<z.ZodBoolean>;
+            patchDigest: z.ZodNullable<z.ZodString>;
+            captureStatus: z.ZodEnum<{
+                complete: "complete";
+                partial: "partial";
+                unknown: "unknown";
+            }>;
+            scope: z.ZodEnum<{
+                external: "external";
+                unknown: "unknown";
+                workspace: "workspace";
+            }>;
+        }, z.core.$strict>>;
+        artifacts: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            digest: z.ZodString;
+            inputVersion: z.ZodNullable<z.ZodString>;
+            observedAt: z.ZodISODateTime;
+        }, z.core.$strict>>;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type ResumePacket = z.infer<typeof resumePacketSchema>;

package/dist/schemas/continuity.js

@@ -0,0 +1,199 @@
+import { z } from 'zod';
+export const TASK_CONTEXT_SCHEMA = 'pappra/task-context/1';
+export const CHECKPOINT_SCHEMA = 'pappra/checkpoint/1';
+export const CHECKPOINT_POINTER_SCHEMA = 'pappra/checkpoint-pointer/1';
+export const RESUME_PACKET_SCHEMA = 'pappra/resume-packet/1';
+const digestSchema = z.string().regex(/^sha256:[0-9a-f]{64}$/);
+const taskIdSchema = z
+    .string()
+    .min(1)
+    .max(64)
+    .regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
+const digestOrNull = digestSchema.nullable();
+const optionalString = z.string().max(4096).nullable();
+export const continuityArtifactPathSchema = z
+    .string()
+    .min(1)
+    .max(2048)
+    .refine((value) => !value.includes('\0') && !value.split('/').includes('..'), 'Artifact path must not contain NUL or parent traversal.');
+export const taskContextSchema = z.strictObject({
+    schema: z.literal(TASK_CONTEXT_SCHEMA),
+    taskId: taskIdSchema,
+    workspaceId: z.uuid(),
+    objective: z.string().min(1).max(4096),
+    acceptance: z.array(z.string().min(1).max(4096)).max(32),
+    constraints: z.array(z.string().min(1).max(4096)).max(32),
+    artifacts: z.array(continuityArtifactPathSchema).max(64),
+    collaborationRecordRef: optionalString,
+    createdAt: z.iso.datetime({ offset: true }),
+    updatedAt: z.iso.datetime({ offset: true }),
+});
+export const checkpointRepositorySchema = z.strictObject({
+    repoId: z.string().min(1).max(64),
+    checkoutId: z.string().min(1).max(128),
+    root: z.string().min(1).max(4096),
+    head: z.string().max(256).nullable(),
+    branch: z.string().max(256).nullable(),
+    dirty: z.boolean().nullable(),
+    patchDigest: digestOrNull,
+    captureStatus: z.enum(['complete', 'partial', 'unknown']),
+    scope: z.enum(['workspace', 'external', 'unknown']),
+});
+export const checkpointArtifactSchema = z.strictObject({
+    path: continuityArtifactPathSchema,
+    digest: digestSchema,
+    inputVersion: z.string().max(256).nullable(),
+    observedAt: z.iso.datetime({ offset: true }),
+});
+export const checkpointValidationSchema = z.strictObject({
+    id: z.string().min(1).max(128),
+    result: z.enum(['passed', 'failed', 'not-run', 'unknown']),
+    inputVersion: z.string().max(256).nullable(),
+    observedAt: z.iso.datetime({ offset: true }),
+});
+export const checkpointNativeRefSchema = z.strictObject({
+    harness: z.enum(['pi', 'codex', 'claude', 'unknown']),
+    sessionId: z.string().max(256).nullable(),
+    turnId: z.string().max(256).nullable(),
+    runId: z.string().max(256).nullable(),
+    scope: z.literal('stored-snapshot'),
+    observedAt: z.iso.datetime({ offset: true }),
+});
+export const checkpointSchema = z.strictObject({
+    schema: z.literal(CHECKPOINT_SCHEMA),
+    checkpointId: z.uuid(),
+    taskId: taskIdSchema,
+    workspaceId: z.uuid(),
+    revision: z.number().int().positive(),
+    previousDigest: digestOrNull,
+    createdAt: z.iso.datetime({ offset: true }),
+    authorSession: z.string().max(256).nullable(),
+    objective: z.string().min(1).max(4096),
+    acceptance: z.array(z.string().min(1).max(4096)).max(32),
+    constraints: z.array(z.string().min(1).max(4096)).max(32),
+    decisions: z.array(z.string().min(1).max(4096)).max(64),
+    attempted: z.array(z.string().min(1).max(4096)).max(64),
+    nextActions: z.array(z.string().min(1).max(4096)).max(64),
+    limitations: z.array(z.string().min(1).max(4096)).max(64),
+    repositories: z.array(checkpointRepositorySchema).max(64),
+    artifacts: z.array(checkpointArtifactSchema).max(64),
+    validations: z.array(checkpointValidationSchema).max(64),
+    nativeRefs: z.array(checkpointNativeRefSchema).max(32),
+    collaborationRecordRef: optionalString,
+    contextCompleteness: z.enum(['complete', 'partial']),
+});
+export const checkpointPointerSchema = z.strictObject({
+    schema: z.literal(CHECKPOINT_POINTER_SCHEMA),
+    taskId: taskIdSchema,
+    workspaceId: z.uuid(),
+    revision: z.number().int().positive(),
+    checkpointRef: z.string().min(1).max(2048),
+    checkpointDigest: digestSchema,
+    updatedAt: z.iso.datetime({ offset: true }),
+});
+const identityCheckSchema = z.strictObject({
+    name: z.string().min(1).max(128),
+    status: z.enum(['ok', 'changed', 'unknown']),
+    detail: z.string().max(2048).nullable(),
+});
+const repositoryDriftSchema = z.strictObject({
+    repoId: z.string().min(1).max(64),
+    status: z.enum(['unchanged', 'changed', 'relocated', 'missing', 'unknown']),
+    storedHead: z.string().max(256).nullable(),
+    currentHead: z.string().max(256).nullable(),
+    storedDirty: z.boolean().nullable(),
+    currentDirty: z.boolean().nullable(),
+    storedPatchDigest: digestOrNull,
+    currentPatchDigest: digestOrNull,
+    storedCheckoutId: z.string().min(1).max(128),
+    currentCheckoutId: z.string().min(1).max(128).nullable(),
+    storedCaptureStatus: z.enum(['complete', 'partial', 'unknown']),
+    currentCaptureStatus: z.enum(['complete', 'partial', 'unknown']),
+    patchStatus: z.enum([
+        'unchanged',
+        'missing',
+        'changed',
+        'unsafe',
+        'not-applicable',
+        'unknown',
+    ]),
+    patchDetail: z.string().max(2048).nullable(),
+    detail: z.string().max(2048).nullable(),
+});
+const artifactCheckSchema = z.strictObject({
+    path: continuityArtifactPathSchema,
+    status: z.enum(['unchanged', 'changed', 'missing', 'unsafe', 'unknown']),
+    detail: z.string().max(2048).nullable(),
+});
+const executionObservationSchema = z.strictObject({
+    harness: z.enum(['pi', 'codex', 'claude', 'unknown']),
+    sessionId: z.string().max(256).nullable(),
+    turnId: z.string().max(256).nullable(),
+    runId: z.string().max(256).nullable(),
+    scope: z.literal('stored-snapshot'),
+    liveStatus: z.literal('unknown'),
+    observedAt: z.iso.datetime({ offset: true }),
+});
+const blockingReasonSchema = z.strictObject({
+    code: z.string().min(1).max(128),
+    message: z.string().min(1).max(2048),
+});
+const collaborationObservationSchema = z.strictObject({
+    ref: z.string().max(4096).nullable(),
+    status: z.enum([
+        'read',
+        'missing',
+        'unreadable',
+        'unsupported',
+        'not-referenced',
+    ]),
+    digest: digestSchema.nullable(),
+    authority: z.strictObject({
+        valid: z.boolean(),
+        stateRevision: z.number().int().nonnegative().nullable(),
+        ownerEpoch: z.number().int().nonnegative().nullable(),
+        dispatchFrozen: z.boolean().nullable(),
+        activeAttempts: z.number().int().nonnegative().nullable(),
+        unreleasedClaims: z.number().int().nonnegative().nullable(),
+        unresolvedUncertainty: z.number().int().nonnegative().nullable(),
+        pendingApprovals: z.number().int().nonnegative().nullable(),
+        blockerCodes: z.array(z.string().min(1).max(128)).max(32),
+    }),
+    scope: z.literal('persisted-history'),
+    liveStatus: z.literal('unknown'),
+});
+export const resumePacketSchema = z.strictObject({
+    schema: z.literal(RESUME_PACKET_SCHEMA),
+    generatedAt: z.iso.datetime({ offset: true }),
+    taskId: taskIdSchema,
+    workspaceId: z.uuid(),
+    checkpoint: z.strictObject({
+        ref: z.string().min(1).max(2048),
+        digest: digestSchema,
+        revision: z.number().int().positive(),
+    }),
+    identityChecks: z.array(identityCheckSchema).max(16),
+    codeDrift: z.strictObject({
+        status: z.enum(['unchanged', 'changed', 'relocated', 'unknown']),
+        repositories: z.array(repositoryDriftSchema).max(64),
+    }),
+    artifactChecks: z.array(artifactCheckSchema).max(64),
+    executionObservations: z.array(executionObservationSchema).max(32),
+    collaborationObservation: collaborationObservationSchema,
+    blockingReasons: z.array(blockingReasonSchema).max(32),
+    executionAllowed: z.boolean(),
+    contextCompleteness: z.enum(['complete', 'partial']),
+    verificationStatus: z.enum(['current', 'stale', 'unknown']),
+    boundedContext: z.strictObject({
+        objective: z.string().min(1).max(4096),
+        acceptance: z.array(z.string().min(1).max(4096)).max(16),
+        constraints: z.array(z.string().min(1).max(4096)).max(16),
+        decisions: z.array(z.string().min(1).max(4096)).max(16),
+        attempted: z.array(z.string().min(1).max(4096)).max(16),
+        nextActions: z.array(z.string().min(1).max(4096)).max(16),
+        limitations: z.array(z.string().min(1).max(4096)).max(16),
+        repositories: z.array(checkpointRepositorySchema).max(16),
+        artifacts: z.array(checkpointArtifactSchema).max(16),
+        truncated: z.boolean(),
+    }),
+});

package/dist/schemas/diagnostics.d.ts

@@ -0,0 +1,28 @@
+import type { DiagnosticCode } from './errors.js';
+export type DiagnosticSeverity = 'error' | 'warning' | 'info';
+/**
+ * A machine-readable finding. `source` is an absolute file path or an
+ * operation label; `pointer` is a JSON pointer inside that source when the
+ * finding refers to a specific value.
+ */
+export interface Diagnostic {
+    readonly code: DiagnosticCode;
+    readonly severity: DiagnosticSeverity;
+    readonly message: string;
+    readonly source: string;
+    readonly pointer: string | null;
+    readonly hint: string | null;
+}
+export interface DiagnosticInput {
+    readonly code: DiagnosticCode;
+    readonly severity: DiagnosticSeverity;
+    readonly message: string;
+    readonly source: string;
+    readonly pointer?: string | null;
+    readonly hint?: string | null;
+}
+export declare function createDiagnostic(input: DiagnosticInput): Diagnostic;
+export declare function hasErrors(diagnostics: readonly Diagnostic[]): boolean;
+export declare function formatDiagnostic(entry: Diagnostic): string;
+/** Builds a JSON pointer such as `/repositories/0/path`. */
+export declare function pointer(...segments: readonly (string | number)[]): string;

package/dist/schemas/diagnostics.js

@@ -0,0 +1,27 @@
+export function createDiagnostic(input) {
+    return {
+        code: input.code,
+        severity: input.severity,
+        message: input.message,
+        source: input.source,
+        pointer: input.pointer ?? null,
+        hint: input.hint ?? null,
+    };
+}
+export function hasErrors(diagnostics) {
+    return diagnostics.some((entry) => entry.severity === 'error');
+}
+export function formatDiagnostic(entry) {
+    const location = entry.pointer === null ? entry.source : `${entry.source}#${entry.pointer}`;
+    const hint = entry.hint === null ? '' : ` Hint: ${entry.hint}`;
+    return `${entry.severity.toUpperCase()} ${entry.code} at ${location}: ${entry.message}${hint}`;
+}
+function escapePointerSegment(segment) {
+    return segment.replaceAll('~', '~0').replaceAll('/', '~1');
+}
+/** Builds a JSON pointer such as `/repositories/0/path`. */
+export function pointer(...segments) {
+    if (segments.length === 0)
+        return '';
+    return `/${segments.map((segment) => escapePointerSegment(String(segment))).join('/')}`;
+}