@phyzess/pappra 0.1.0-beta.13 → 0.1.0-beta.18

package/dist/schemas/collaboration.d.ts

@@ -14,6 +14,7 @@ export declare const collaborationGoalSchema: z.ZodObject<{
     objective: z.ZodString;
     acceptance: z.ZodArray<z.ZodString>;
     prompt: z.ZodString;
+    roles: z.ZodDefault<z.ZodArray<z.ZodString>>;
     coordinator: z.ZodObject<{
         agent_id: z.ZodString;
         session_id: z.ZodString;
@@ -113,3 +114,337 @@ export declare const collaborationEventSchema: z.ZodObject<{
     data: z.ZodNullable<z.ZodUnknown>;
 }, z.core.$strict>;
 export type CollaborationEvent = z.infer<typeof collaborationEventSchema>;
+/**
+ * Task-scoped resource request. Claims use the existing canonical resource
+ * kinds/semantics; release names one explicit claim and holder. Free-form
+ * request bodies are never echoed in diagnostics.
+ */
+export declare const COLLAB_RESOURCE_REQUEST_SCHEMA = "pappra/collaboration-resource-request/1";
+export declare const collaborationResourceRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/collaboration-resource-request/1">;
+    action: z.ZodLiteral<"claim">;
+    holder: z.ZodObject<{
+        agent_id: z.ZodString;
+        session_id: z.ZodString;
+        harness: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strict>;
+    resources: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        path: z.ZodString;
+        scope: z.ZodOptional<z.ZodEnum<{
+            file: "file";
+            tree: "tree";
+        }>>;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodEnum<{
+            "build-cache": "build-cache";
+            file: "file";
+            "git-common-dir": "git-common-dir";
+            "git-head": "git-head";
+            "git-index": "git-index";
+            path: "path";
+        }>;
+        path: z.ZodString;
+        scope: z.ZodOptional<z.ZodEnum<{
+            file: "file";
+            tree: "tree";
+        }>>;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"port">;
+        port: z.ZodNumber;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodEnum<{
+            opaque: "opaque";
+            process: "process";
+        }>;
+        value: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>]>>;
+    access: z.ZodEnum<{
+        read: "read";
+        write: "write";
+    }>;
+    include_shared_git: z.ZodOptional<z.ZodBoolean>;
+    note: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    subtask_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    attempt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/collaboration-resource-request/1">;
+    action: z.ZodLiteral<"release">;
+    holder: z.ZodObject<{
+        agent_id: z.ZodString;
+        session_id: z.ZodString;
+        harness: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strict>;
+    claim_id: z.ZodString;
+    reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>], "action">;
+export type CollaborationResourceRequest = z.infer<typeof collaborationResourceRequestSchema>;
+/**
+ * Recorded handoff requests. Action fields map directly to the existing
+ * handoff primitives; actor/owner_epoch are editable protocol inputs, not
+ * authentication. No clock or inline confirmation envelope is accepted.
+ */
+export declare const COLLAB_HANDOFF_REQUEST_SCHEMA = "pappra/collaboration-handoff-request/1";
+export declare const collaborationHandoffRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/collaboration-handoff-request/1">;
+    actor: z.ZodString;
+    owner_epoch: z.ZodNumber;
+    expect_revision: z.ZodOptional<z.ZodNumber>;
+    action: z.ZodLiteral<"begin">;
+    handoff_id: z.ZodString;
+    kind: z.ZodEnum<{
+        coordinator: "coordinator";
+        writer: "writer";
+    }>;
+    from: z.ZodObject<{
+        agent_id: z.ZodString;
+        session_id: z.ZodString;
+        harness: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strict>;
+    to: z.ZodObject<{
+        agent_id: z.ZodString;
+        session_id: z.ZodString;
+        harness: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strict>;
+    resources: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    subtask_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    attempt: z.ZodOptional<z.ZodNumber>;
+    reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>, z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/collaboration-handoff-request/1">;
+    actor: z.ZodString;
+    owner_epoch: z.ZodNumber;
+    expect_revision: z.ZodOptional<z.ZodNumber>;
+    action: z.ZodLiteral<"stopped">;
+    handoff_id: z.ZodString;
+    observation: z.ZodString;
+    evidence_ref: z.ZodString;
+    detail: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>, z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/collaboration-handoff-request/1">;
+    actor: z.ZodString;
+    owner_epoch: z.ZodNumber;
+    expect_revision: z.ZodOptional<z.ZodNumber>;
+    action: z.ZodLiteral<"rebind">;
+    handoff_id: z.ZodString;
+    to: z.ZodObject<{
+        agent_id: z.ZodString;
+        session_id: z.ZodString;
+        harness: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strict>;
+    evidence_ref: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/collaboration-handoff-request/1">;
+    actor: z.ZodString;
+    owner_epoch: z.ZodNumber;
+    expect_revision: z.ZodOptional<z.ZodNumber>;
+    action: z.ZodLiteral<"transfer">;
+    handoff_id: z.ZodString;
+    partial_outputs: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    inflight: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    pending_approvals: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+}, z.core.$strict>, z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/collaboration-handoff-request/1">;
+    actor: z.ZodString;
+    owner_epoch: z.ZodNumber;
+    expect_revision: z.ZodOptional<z.ZodNumber>;
+    action: z.ZodLiteral<"confirm">;
+    handoff_id: z.ZodString;
+    confirmation_message_id: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/collaboration-handoff-request/1">;
+    actor: z.ZodString;
+    owner_epoch: z.ZodNumber;
+    expect_revision: z.ZodOptional<z.ZodNumber>;
+    action: z.ZodLiteral<"complete">;
+    handoff_id: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/collaboration-handoff-request/1">;
+    actor: z.ZodString;
+    owner_epoch: z.ZodNumber;
+    expect_revision: z.ZodOptional<z.ZodNumber>;
+    action: z.ZodLiteral<"abort">;
+    handoff_id: z.ZodString;
+    reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>, z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/collaboration-handoff-request/1">;
+    actor: z.ZodString;
+    owner_epoch: z.ZodNumber;
+    expect_revision: z.ZodOptional<z.ZodNumber>;
+    action: z.ZodLiteral<"release-dispatch">;
+}, z.core.$strict>], "action">;
+export type CollaborationHandoffRequest = z.infer<typeof collaborationHandoffRequestSchema>;
+/**
+ * Explicit recovery requests: reconcile one uncertainty and optionally apply an
+ * existing state transition atomically, or break one task write lock after an
+ * operator stop assertion and an exact inspected fingerprint.
+ */
+export declare const COLLAB_RECOVERY_REQUEST_SCHEMA = "pappra/collaboration-recovery-request/1";
+export declare const collaborationRecoveryRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/collaboration-recovery-request/1">;
+    actor: z.ZodString;
+    owner_epoch: z.ZodNumber;
+    action: z.ZodLiteral<"reconcile">;
+    uncertainty_id: z.ZodString;
+    resolution: z.ZodString;
+    resolution_evidence: z.ZodString;
+    expect_revision: z.ZodOptional<z.ZodNumber>;
+    set_state: z.ZodOptional<z.ZodEnum<{
+        accepted: "accepted";
+        assigned: "assigned";
+        cancelled: "cancelled";
+        completed: "completed";
+        failed: "failed";
+        needs_input: "needs_input";
+        running: "running";
+        unknown: "unknown";
+    }>>;
+}, z.core.$strict>, z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/collaboration-recovery-request/1">;
+    actor: z.ZodString;
+    owner_epoch: z.ZodNumber;
+    action: z.ZodLiteral<"lock-break">;
+    reason: z.ZodString;
+    confirm_holder_stopped: z.ZodLiteral<true>;
+    expected_lock_fingerprint: z.ZodString;
+}, z.core.$strict>], "action">;
+export type CollaborationRecoveryRequest = z.infer<typeof collaborationRecoveryRequestSchema>;
+/**
+ * Task-local routing metadata for explicit notification. A binding maps exact
+ * protocol participants to named Herdr agents; it grants no authority and is not
+ * proof that a native session exists.
+ */
+export declare const COLLAB_BINDING_SCHEMA = "pappra/collab-binding/1";
+export declare const COLLAB_DELIVERY_SCHEMA = "pappra/collab-delivery/1";
+export declare const collabBindingParticipantSchema: z.ZodObject<{
+    agent_id: z.ZodString;
+    harness: z.ZodString;
+    cwd: z.ZodString;
+    herdr_agent: z.ZodString;
+    pane_id: z.ZodString;
+    native_session_id: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type CollabBindingParticipant = z.infer<typeof collabBindingParticipantSchema>;
+export declare const collabBindingSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/collab-binding/1">;
+    task_id: z.ZodString;
+    task_root: z.ZodString;
+    channel: z.ZodLiteral<"herdr">;
+    participants: z.ZodArray<z.ZodObject<{
+        agent_id: z.ZodString;
+        harness: z.ZodString;
+        cwd: z.ZodString;
+        herdr_agent: z.ZodString;
+        pane_id: z.ZodString;
+        native_session_id: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type CollabBinding = z.infer<typeof collabBindingSchema>;
+export declare const collabDeliveryStatusSchema: z.ZodEnum<{
+    blocked: "blocked";
+    failed: "failed";
+    refused: "refused";
+    submitted: "submitted";
+    submitting: "submitting";
+    unknown: "unknown";
+}>;
+export type CollabDeliveryStatus = z.infer<typeof collabDeliveryStatusSchema>;
+export declare const collabDeliveryAttemptSchema: z.ZodObject<{
+    at: z.ZodString;
+    status: z.ZodEnum<{
+        blocked: "blocked";
+        failed: "failed";
+        refused: "refused";
+        submitted: "submitted";
+        submitting: "submitting";
+        unknown: "unknown";
+    }>;
+    detail: z.ZodNullable<z.ZodString>;
+    reservation_id: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type CollabDeliveryAttempt = z.infer<typeof collabDeliveryAttemptSchema>;
+/**
+ * Optional caller-routing evidence. Selecting a pane (current or explicit) is
+ * routing, not sender authentication: process affiliation is not established.
+ */
+export declare const collabDeliveryCallerSchema: z.ZodObject<{
+    source: z.ZodEnum<{
+        current: "current";
+        explicit: "explicit";
+    }>;
+    pane_id: z.ZodString;
+    harness: z.ZodNullable<z.ZodString>;
+    cwd: z.ZodNullable<z.ZodString>;
+    observed_at: z.ZodString;
+    native_session: z.ZodEnum<{
+        match: "match";
+        unknown: "unknown";
+    }>;
+    native_session_kind: z.ZodNullable<z.ZodString>;
+    process_affiliation: z.ZodLiteral<"not-established">;
+}, z.core.$strict>;
+export type CollabDeliveryCaller = z.infer<typeof collabDeliveryCallerSchema>;
+export declare const collabDeliverySchema: z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/collab-delivery/1">;
+    message_id: z.ZodString;
+    message_path: z.ZodString;
+    message_digest: z.ZodString;
+    task_id: z.ZodString;
+    task_root: z.ZodString;
+    recipient: z.ZodObject<{
+        agent_id: z.ZodString;
+        harness: z.ZodString;
+    }, z.core.$strict>;
+    target: z.ZodObject<{
+        herdr_agent: z.ZodString;
+        pane_id: z.ZodString;
+        native_session: z.ZodEnum<{
+            match: "match";
+            unknown: "unknown";
+        }>;
+        native_session_kind: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strict>;
+    caller: z.ZodOptional<z.ZodObject<{
+        source: z.ZodEnum<{
+            current: "current";
+            explicit: "explicit";
+        }>;
+        pane_id: z.ZodString;
+        harness: z.ZodNullable<z.ZodString>;
+        cwd: z.ZodNullable<z.ZodString>;
+        observed_at: z.ZodString;
+        native_session: z.ZodEnum<{
+            match: "match";
+            unknown: "unknown";
+        }>;
+        native_session_kind: z.ZodNullable<z.ZodString>;
+        process_affiliation: z.ZodLiteral<"not-established">;
+    }, z.core.$strict>>;
+    status: z.ZodEnum<{
+        blocked: "blocked";
+        failed: "failed";
+        refused: "refused";
+        submitted: "submitted";
+        submitting: "submitting";
+        unknown: "unknown";
+    }>;
+    attempts: z.ZodArray<z.ZodObject<{
+        at: z.ZodString;
+        status: z.ZodEnum<{
+            blocked: "blocked";
+            failed: "failed";
+            refused: "refused";
+            submitted: "submitted";
+            submitting: "submitting";
+            unknown: "unknown";
+        }>;
+        detail: z.ZodNullable<z.ZodString>;
+        reservation_id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+}, z.core.$strict>;
+export type CollabDelivery = z.infer<typeof collabDeliverySchema>;

package/dist/schemas/collaboration.js

@@ -29,6 +29,13 @@ const resource = z.strictObject({
     path: absolutePath,
     access: z.enum(['read', 'write']),
 });
+const roles = z
+    .array(z.string().min(1).max(64))
+    .min(1)
+    .max(8)
+    .refine((entries) => new Set(entries).size === entries.length, {
+    message: 'roles must be unique',
+});
 export const collaborationGoalSchema = z.strictObject({
     schema: z.literal('pappra/collaboration-goal/1'),
     task_id: taskId,
@@ -38,6 +45,7 @@ export const collaborationGoalSchema = z.strictObject({
     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),
+    roles: roles.default(['implementer']),
     coordinator: identity.extend({ owner_epoch: z.number().int().min(1) }),
     assignee: identity.extend({
         cwd: absolutePath,
@@ -104,3 +112,267 @@ export const collaborationEventSchema = z.strictObject({
     detail: z.string().max(4096).nullable(),
     data: z.unknown().nullable(),
 });
+/**
+ * Task-scoped resource request. Claims use the existing canonical resource
+ * kinds/semantics; release names one explicit claim and holder. Free-form
+ * request bodies are never echoed in diagnostics.
+ */
+export const COLLAB_RESOURCE_REQUEST_SCHEMA = 'pappra/collaboration-resource-request/1';
+const resourceHolder = 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).nullable().optional(),
+});
+const pathResourceKind = z.enum([
+    'path',
+    'git-index',
+    'git-head',
+    'git-common-dir',
+    'build-cache',
+    'file',
+]);
+const pathResource = z.strictObject({
+    kind: pathResourceKind,
+    path: absolutePath,
+    scope: z.enum(['file', 'tree']).optional(),
+    label: z.string().min(1).max(512).optional(),
+});
+const defaultPathResource = z.strictObject({
+    path: absolutePath,
+    scope: z.enum(['file', 'tree']).optional(),
+    label: z.string().min(1).max(512).optional(),
+});
+const portResource = z.strictObject({
+    kind: z.literal('port'),
+    port: z.number().int().min(1).max(65535),
+    label: z.string().min(1).max(512).optional(),
+});
+const opaqueResource = z.strictObject({
+    kind: z.enum(['opaque', 'process']),
+    value: z.string().min(1).max(4096),
+    label: z.string().min(1).max(512).optional(),
+});
+const requestResource = z.union([
+    defaultPathResource,
+    pathResource,
+    portResource,
+    opaqueResource,
+]);
+export const collaborationResourceRequestSchema = z.discriminatedUnion('action', [
+    z.strictObject({
+        schema: z.literal(COLLAB_RESOURCE_REQUEST_SCHEMA),
+        action: z.literal('claim'),
+        holder: resourceHolder,
+        resources: z.array(requestResource).min(1).max(256),
+        access: z.enum(['read', 'write']),
+        include_shared_git: z.boolean().optional(),
+        note: z.string().max(4096).nullable().optional(),
+        subtask_id: z.string().min(1).max(128).nullable().optional(),
+        attempt: z.number().int().min(1).optional(),
+    }),
+    z.strictObject({
+        schema: z.literal(COLLAB_RESOURCE_REQUEST_SCHEMA),
+        action: z.literal('release'),
+        holder: resourceHolder,
+        claim_id: z.string().min(1).max(512),
+        reason: z.string().max(4096).nullable().optional(),
+    }),
+]);
+/**
+ * Recorded handoff requests. Action fields map directly to the existing
+ * handoff primitives; actor/owner_epoch are editable protocol inputs, not
+ * authentication. No clock or inline confirmation envelope is accepted.
+ */
+export const COLLAB_HANDOFF_REQUEST_SCHEMA = 'pappra/collaboration-handoff-request/1';
+const handoffIdentity = 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).nullable().optional(),
+});
+const handoffBase = {
+    schema: z.literal(COLLAB_HANDOFF_REQUEST_SCHEMA),
+    actor: z.string().min(1).max(128),
+    owner_epoch: z.number().int().min(1),
+    expect_revision: z.number().int().min(0).optional(),
+};
+const handoffId = z.string().min(1).max(256);
+const evidenceRef = z.string().min(1).max(4096);
+const handoffReason = z.string().max(4096).nullable().optional();
+const handoffInventoryList = z.array(z.unknown()).max(128).optional();
+export const collaborationHandoffRequestSchema = z.discriminatedUnion('action', [
+    z.strictObject({
+        ...handoffBase,
+        action: z.literal('begin'),
+        handoff_id: handoffId,
+        kind: z.enum(['writer', 'coordinator']),
+        from: handoffIdentity,
+        to: handoffIdentity,
+        resources: z.array(z.string().min(1).max(256)).max(64).optional(),
+        subtask_id: z.string().min(1).max(128).nullable().optional(),
+        attempt: z.number().int().min(1).optional(),
+        reason: handoffReason,
+    }),
+    z.strictObject({
+        ...handoffBase,
+        action: z.literal('stopped'),
+        handoff_id: handoffId,
+        observation: z.string().min(1).max(128),
+        evidence_ref: evidenceRef,
+        detail: z.string().max(4096).nullable().optional(),
+    }),
+    z.strictObject({
+        ...handoffBase,
+        action: z.literal('rebind'),
+        handoff_id: handoffId,
+        to: handoffIdentity,
+        evidence_ref: evidenceRef,
+    }),
+    z.strictObject({
+        ...handoffBase,
+        action: z.literal('transfer'),
+        handoff_id: handoffId,
+        partial_outputs: handoffInventoryList,
+        inflight: handoffInventoryList,
+        pending_approvals: handoffInventoryList,
+    }),
+    z.strictObject({
+        ...handoffBase,
+        action: z.literal('confirm'),
+        handoff_id: handoffId,
+        confirmation_message_id: z.string().min(1).max(256),
+    }),
+    z.strictObject({
+        ...handoffBase,
+        action: z.literal('complete'),
+        handoff_id: handoffId,
+    }),
+    z.strictObject({
+        ...handoffBase,
+        action: z.literal('abort'),
+        handoff_id: handoffId,
+        reason: handoffReason,
+    }),
+    z.strictObject({
+        ...handoffBase,
+        action: z.literal('release-dispatch'),
+    }),
+]);
+/**
+ * Explicit recovery requests: reconcile one uncertainty and optionally apply an
+ * existing state transition atomically, or break one task write lock after an
+ * operator stop assertion and an exact inspected fingerprint.
+ */
+export const COLLAB_RECOVERY_REQUEST_SCHEMA = 'pappra/collaboration-recovery-request/1';
+const recoveryBase = {
+    schema: z.literal(COLLAB_RECOVERY_REQUEST_SCHEMA),
+    actor: z.string().min(1).max(128),
+    owner_epoch: z.number().int().min(1),
+};
+const attemptState = z.enum([
+    'assigned',
+    'accepted',
+    'running',
+    'completed',
+    'needs_input',
+    'failed',
+    'cancelled',
+    'unknown',
+]);
+export const collaborationRecoveryRequestSchema = z.discriminatedUnion('action', [
+    z.strictObject({
+        ...recoveryBase,
+        action: z.literal('reconcile'),
+        uncertainty_id: z.string().min(1).max(128),
+        resolution: z.string().min(1).max(4096),
+        resolution_evidence: z.string().min(1).max(4096),
+        expect_revision: z.number().int().min(0).optional(),
+        set_state: attemptState.optional(),
+    }),
+    z.strictObject({
+        ...recoveryBase,
+        action: z.literal('lock-break'),
+        reason: z.string().min(1).max(4096),
+        confirm_holder_stopped: z.literal(true),
+        expected_lock_fingerprint: z.string().min(1).max(128),
+    }),
+]);
+/**
+ * Task-local routing metadata for explicit notification. A binding maps exact
+ * protocol participants to named Herdr agents; it grants no authority and is not
+ * proof that a native session exists.
+ */
+export const COLLAB_BINDING_SCHEMA = 'pappra/collab-binding/1';
+export const COLLAB_DELIVERY_SCHEMA = 'pappra/collab-delivery/1';
+const herdrPaneId = z
+    .string()
+    .regex(/^[A-Za-z0-9]+:p[A-Za-z0-9]+$/, 'Use a Herdr pane id such as w3:p3.');
+const participantId = z.string().min(1).max(128);
+export const collabBindingParticipantSchema = z.strictObject({
+    agent_id: participantId,
+    harness: z.string().min(1).max(64),
+    cwd: absolutePath,
+    herdr_agent: z.string().min(1).max(128),
+    pane_id: herdrPaneId,
+    native_session_id: z.string().min(1).max(256).nullable(),
+});
+export const collabBindingSchema = z.strictObject({
+    schema: z.literal(COLLAB_BINDING_SCHEMA),
+    task_id: participantId,
+    task_root: absolutePath,
+    channel: z.literal('herdr'),
+    participants: z.array(collabBindingParticipantSchema).min(1).max(16),
+});
+export const collabDeliveryStatusSchema = z.enum([
+    'submitting',
+    'submitted',
+    'blocked',
+    'refused',
+    'unknown',
+    'failed',
+]);
+export const collabDeliveryAttemptSchema = z.strictObject({
+    at: z.string().min(1),
+    status: collabDeliveryStatusSchema,
+    detail: z.string().max(4096).nullable(),
+    /** Present for attempts reserved after the C0 repair; older evidence omits it. */
+    reservation_id: z.string().min(1).max(64).optional(),
+});
+/**
+ * Optional caller-routing evidence. Selecting a pane (current or explicit) is
+ * routing, not sender authentication: process affiliation is not established.
+ */
+export const collabDeliveryCallerSchema = z.strictObject({
+    source: z.enum(['current', 'explicit']),
+    pane_id: herdrPaneId,
+    harness: z.string().min(1).max(64).nullable(),
+    cwd: z.string().min(1).max(4096).nullable(),
+    observed_at: z.string().min(1),
+    native_session: z.enum(['match', 'unknown']),
+    native_session_kind: z.string().min(1).max(64).nullable(),
+    process_affiliation: z.literal('not-established'),
+});
+export const collabDeliverySchema = z.strictObject({
+    schema: z.literal(COLLAB_DELIVERY_SCHEMA),
+    message_id: participantId,
+    message_path: z.string().min(1).max(4096),
+    message_digest: z.string().regex(/^sha256:[0-9a-f]{64}$/),
+    task_id: participantId,
+    task_root: absolutePath,
+    recipient: z.strictObject({
+        agent_id: participantId,
+        harness: z.string().min(1).max(64),
+    }),
+    target: z.strictObject({
+        herdr_agent: z.string().min(1).max(128),
+        pane_id: herdrPaneId,
+        native_session: z.enum(['match', 'unknown']),
+        /** Reported Herdr session kind (`path`, `id`, ...); older evidence omits it. */
+        native_session_kind: z.string().min(1).max(64).nullable().optional(),
+    }),
+    /** Present for caller-routing evidence recorded after C1; older records omit it. */
+    caller: collabDeliveryCallerSchema.optional(),
+    status: collabDeliveryStatusSchema,
+    attempts: z.array(collabDeliveryAttemptSchema).max(8),
+    created_at: z.string().min(1),
+    updated_at: z.string().min(1),
+});

package/dist/schemas/continuity.d.ts

@@ -3,6 +3,14 @@ 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";
+/**
+ * One task identifier rule for pin records, continuity paths and schemas:
+ * up to 64 characters from letters, digits, dot, dash and underscore, starting
+ * with a letter or digit. Invalid identifiers are rejected before any write.
+ */
+export declare const TASK_ID_MAX_LENGTH = 64;
+export declare const taskIdSchema: z.ZodString;
+export declare function isValidTaskId(value: string): boolean;
 export declare const continuityArtifactPathSchema: z.ZodString;
 export declare const taskContextSchema: z.ZodObject<{
     schema: z.ZodLiteral<"pappra/task-context/1">;

package/dist/schemas/continuity.js

@@ -4,11 +4,21 @@ 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
+/**
+ * One task identifier rule for pin records, continuity paths and schemas:
+ * up to 64 characters from letters, digits, dot, dash and underscore, starting
+ * with a letter or digit. Invalid identifiers are rejected before any write.
+ */
+export const TASK_ID_MAX_LENGTH = 64;
+const TASK_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+export const taskIdSchema = z
     .string()
     .min(1)
-    .max(64)
-    .regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
+    .max(TASK_ID_MAX_LENGTH)
+    .regex(TASK_ID_PATTERN, 'Use a letter or digit followed by letters, digits, dot, underscore or dash.');
+export function isValidTaskId(value) {
+    return value.length <= TASK_ID_MAX_LENGTH && TASK_ID_PATTERN.test(value);
+}
 const digestOrNull = digestSchema.nullable();
 const optionalString = z.string().max(4096).nullable();
 export const continuityArtifactPathSchema = z

package/dist/schemas/doctor.d.ts

@@ -86,6 +86,7 @@ export declare const doctorReportSchema: z.ZodObject<{
         passiveStatus: z.ZodNullable<z.ZodEnum<{
             "content-match": "content-match";
             corrupt: "corrupt";
+            incompatible: "incompatible";
             locked: "locked";
             missing: "missing";
             partial: "partial";

package/dist/schemas/doctor.js

@@ -51,6 +51,7 @@ export const doctorReportSchema = z.strictObject({
             'locked',
             'partial',
             'unreadable',
+            'incompatible',
         ])
             .nullable(),
     }),