@open-agent-toolkit/cli 0.2.64 → 0.2.66

package/dist/commands/pjm/remote/operation-state.js

@@ -0,0 +1,143 @@
+export const OPERATION_STATES = [
+    'planned',
+    'pending',
+    'authorized',
+    'attempt-started',
+    'verification-pending',
+    'blocked',
+    'verified',
+    'partial',
+    'uncertain',
+    'failed',
+    'rejected',
+];
+const VALID_TRANSITIONS = {
+    planned: new Set(['pending', 'authorized', 'blocked', 'failed']),
+    pending: new Set(['authorized', 'blocked', 'failed']),
+    authorized: new Set(['attempt-started', 'blocked', 'failed']),
+    'attempt-started': new Set([
+        'verification-pending',
+        'partial',
+        'uncertain',
+        'rejected',
+    ]),
+    'verification-pending': new Set(['verified', 'partial', 'uncertain']),
+    blocked: new Set(),
+    verified: new Set(),
+    partial: new Set(),
+    uncertain: new Set(),
+    failed: new Set(),
+    rejected: new Set(),
+};
+const ATTEMPTED_STATES = new Set([
+    'attempt-started',
+    'verification-pending',
+    'verified',
+    'partial',
+    'uncertain',
+    'rejected',
+]);
+const ADVERSE_STATES = new Set([
+    'partial',
+    'uncertain',
+    'rejected',
+    'blocked',
+    'failed',
+]);
+export function transitionRemoteOperation(current, next, subject = 'parent') {
+    if (!VALID_TRANSITIONS[current].has(next)) {
+        throw new Error(`Invalid remote ${subject} transition from '${current}' to '${next}'.`);
+    }
+    return next;
+}
+export function reduceCompositeOperationState(substeps) {
+    if (substeps.length === 0) {
+        throw new Error('Composite operation reduction requires substeps.');
+    }
+    const ids = substeps.map((substep) => substep.substepId);
+    if (new Set(ids).size !== ids.length) {
+        throw new Error('Composite substep IDs must be unique.');
+    }
+    for (const [index, substep] of substeps.entries()) {
+        if (index > 0 &&
+            ATTEMPTED_STATES.has(substep.state) &&
+            substeps
+                .slice(0, index)
+                .some((dependency) => dependency.state !== 'verified')) {
+            throw new Error(`Composite substep '${substep.substepId}' attempted before its dependency verified.`);
+        }
+    }
+    const verifiedSubstepIds = substeps
+        .filter((substep) => substep.state === 'verified')
+        .map((substep) => substep.substepId);
+    const allVerified = verifiedSubstepIds.length === substeps.length;
+    if (allVerified) {
+        return {
+            state: 'verified',
+            verifiedSubstepIds,
+            continuableSubstepId: null,
+            retryDisposition: 'not-applicable',
+        };
+    }
+    const states = new Set(substeps.map((substep) => substep.state));
+    let state;
+    if (states.has('partial') ||
+        (verifiedSubstepIds.length > 0 &&
+            substeps.some((substep) => ADVERSE_STATES.has(substep.state)))) {
+        state = 'partial';
+    }
+    else if (states.has('uncertain')) {
+        state = 'uncertain';
+    }
+    else if (states.has('rejected')) {
+        state = 'rejected';
+    }
+    else if (states.has('verification-pending')) {
+        state = 'verification-pending';
+    }
+    else if (states.has('attempt-started')) {
+        state = 'attempt-started';
+    }
+    else if (states.has('failed')) {
+        state = 'failed';
+    }
+    else if (states.has('blocked')) {
+        state = 'blocked';
+    }
+    else {
+        const next = firstContinuableSubstep(substeps);
+        state = next?.state ?? 'planned';
+    }
+    const reconcileRequired = state === 'partial' ||
+        state === 'uncertain' ||
+        state === 'rejected' ||
+        state === 'attempt-started' ||
+        state === 'verification-pending';
+    const continuable = reconcileRequired
+        ? null
+        : (firstContinuableSubstep(substeps)?.substepId ?? null);
+    return {
+        state,
+        verifiedSubstepIds,
+        continuableSubstepId: continuable,
+        retryDisposition: reconcileRequired
+            ? 'reconcile-required'
+            : continuable
+                ? 'safe-before-attempt'
+                : 'not-applicable',
+    };
+}
+function firstContinuableSubstep(substeps) {
+    for (const [index, substep] of substeps.entries()) {
+        if (substep.state === 'verified')
+            continue;
+        if (!['planned', 'pending', 'authorized'].includes(substep.state) ||
+            substeps
+                .slice(0, index)
+                .some((dependency) => dependency.state !== 'verified')) {
+            return null;
+        }
+        return substep;
+    }
+    return null;
+}

package/dist/commands/pjm/remote/outbound-projection-safety.d.ts

@@ -0,0 +1,25 @@
+export interface OutboundProjection {
+    title?: string;
+    description?: string | null;
+    priority?: string | null;
+    status?: string;
+    annotation?: string;
+    sourceRevision?: string;
+}
+export interface OutboundProjectionSafetyResult {
+    schemaVersion: 1;
+    projectionDigest: string;
+    verdict: 'safe' | 'blocked';
+    resultDigest: string;
+    reasons: Array<{
+        code: 'sensitive-content' | 'private-artifact' | 'invalid-projection';
+        field: keyof OutboundProjection | null;
+    }>;
+    assessedAt: string;
+}
+export declare function digestOutboundProjection(projection: OutboundProjection): string;
+export declare function assessOutboundProjectionSafety(projection: OutboundProjection, options: {
+    assessedAt: string;
+}): OutboundProjectionSafetyResult;
+export declare function requireCurrentOutboundSafety(projection: OutboundProjection, result: OutboundProjectionSafetyResult | null | undefined): asserts result is OutboundProjectionSafetyResult;
+//# sourceMappingURL=outbound-projection-safety.d.ts.map

package/dist/commands/pjm/remote/outbound-projection-safety.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outbound-projection-safety.d.ts","sourceRoot":"","sources":["../../../../src/commands/pjm/remote/outbound-projection-safety.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,kBAAkB;IACjC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,8BAA8B;IAC7C,aAAa,EAAE,CAAC,CAAC;IACjB,gBAAgB,EAAE,MAAM,CAAC;IACzB,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,KAAK,CAAC;QACb,IAAI,EAAE,mBAAmB,GAAG,kBAAkB,GAAG,oBAAoB,CAAC;QACtE,KAAK,EAAE,MAAM,kBAAkB,GAAG,IAAI,CAAC;KACxC,CAAC,CAAC;IACH,UAAU,EAAE,MAAM,CAAC;CACpB;AAiBD,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,kBAAkB,GAC7B,MAAM,CAER;AAED,wBAAgB,8BAA8B,CAC5C,UAAU,EAAE,kBAAkB,EAC9B,OAAO,EAAE;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,GAC9B,8BAA8B,CA8ChC;AAED,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,kBAAkB,EAC9B,MAAM,EAAE,8BAA8B,GAAG,IAAI,GAAG,SAAS,GACxD,OAAO,CAAC,MAAM,IAAI,8BAA8B,CAiBlD"}

package/dist/commands/pjm/remote/outbound-projection-safety.js

@@ -0,0 +1,99 @@
+import { createHash } from 'node:crypto';
+import { containsSensitiveContentSignalInValue } from './credential-safety.js';
+const ALLOWED_FIELDS = new Set([
+    'title',
+    'description',
+    'priority',
+    'status',
+    'annotation',
+    'sourceRevision',
+]);
+const PRIVATE_ARTIFACT_MARKERS = [
+    '.oat/projects/',
+    'discovery.md',
+    'implementation.md',
+    'review artifact',
+];
+export function digestOutboundProjection(projection) {
+    return digest(projection);
+}
+export function assessOutboundProjectionSafety(projection, options) {
+    if (!Number.isFinite(Date.parse(options.assessedAt))) {
+        throw new Error('Outbound safety assessment requires a valid timestamp.');
+    }
+    const reasons = [];
+    for (const [rawField, value] of Object.entries(projection)) {
+        const field = rawField;
+        if (!ALLOWED_FIELDS.has(field) ||
+            (value !== null && typeof value !== 'string')) {
+            reasons.push({
+                code: 'invalid-projection',
+                field: ALLOWED_FIELDS.has(field) ? field : null,
+            });
+            continue;
+        }
+        if (containsSensitiveContentSignalInValue(value)) {
+            reasons.push({ code: 'sensitive-content', field });
+        }
+        if (typeof value === 'string' &&
+            PRIVATE_ARTIFACT_MARKERS.some((marker) => value.toLowerCase().includes(marker))) {
+            reasons.push({ code: 'private-artifact', field });
+        }
+    }
+    const projectionDigest = digest(projection);
+    const verdict = reasons.length === 0 ? 'safe' : 'blocked';
+    const resultDigest = digest({
+        schemaVersion: 1,
+        projectionDigest,
+        verdict,
+        reasons,
+        assessedAt: options.assessedAt,
+    });
+    return {
+        schemaVersion: 1,
+        projectionDigest,
+        verdict,
+        resultDigest,
+        reasons,
+        assessedAt: options.assessedAt,
+    };
+}
+export function requireCurrentOutboundSafety(projection, result) {
+    if (!result)
+        throw new Error('Outbound safety evidence is missing.');
+    if (result.verdict !== 'safe')
+        throw new Error('Outbound safety evidence blocks execution.');
+    if (result.projectionDigest !== digestOutboundProjection(projection)) {
+        throw new Error('Outbound safety evidence is stale or mismatched.');
+    }
+    const expectedResultDigest = digest({
+        schemaVersion: result.schemaVersion,
+        projectionDigest: result.projectionDigest,
+        verdict: result.verdict,
+        reasons: result.reasons,
+        assessedAt: result.assessedAt,
+    });
+    if (expectedResultDigest !== result.resultDigest) {
+        throw new Error('Outbound safety result digest is invalid.');
+    }
+}
+function digest(value) {
+    return `sha256:${createHash('sha256')
+        .update(JSON.stringify(canonicalize(value)))
+        .digest('hex')}`;
+}
+function canonicalize(value) {
+    if (value === null || ['string', 'boolean'].includes(typeof value))
+        return value;
+    if (typeof value === 'number')
+        return value;
+    if (Array.isArray(value))
+        return value.map(canonicalize);
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value)
+            .filter(([, item]) => item !== undefined)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, item]) => [key, canonicalize(item)]));
+    }
+    throw new Error('Outbound projection contains an unsupported value.');
+}

package/dist/commands/pjm/remote/output.d.ts

@@ -0,0 +1,60 @@
+import type { DiscussionEvidence } from './discussion.js';
+import type { ExternalActionEnvelope } from './external-action.js';
+import type { BindingPreview } from './preview.js';
+export type RemoteCommandStatus = 'ok' | 'pending' | 'needs-review' | 'partial' | 'uncertain' | 'blocked' | 'rejected' | 'failed';
+export interface RemoteCommandEnvelope {
+    schemaVersion: 1;
+    status: RemoteCommandStatus;
+    operation: string;
+    projectRoot: string;
+    persisted: boolean;
+    results: Array<{
+        bindingId: string;
+        provider: 'github' | 'linear' | 'jira';
+        target: string;
+        status: RemoteCommandStatus;
+        freshness: string;
+        authority: string;
+        diagnosticCode: string | null;
+    }>;
+    externalAction: ExternalActionEnvelope | null;
+    discussionEvidence?: DiscussionEvidence;
+    approvalPreview?: {
+        operationId: string;
+        digest: string;
+        operationClass: BindingPreview['operationClass'];
+        fieldMask: BindingPreview['fieldMask'];
+        renderedFields: Partial<BindingPreview['renderedFields']>;
+        authority: string;
+        componentDigests: {
+            target: string;
+            baseline: string;
+            capability: string;
+            authority: string;
+            policy: string;
+            projection: string;
+            outboundSafety: string;
+        };
+        revision: {
+            digest: string;
+            evidenceDigest: string;
+            source: 'remote' | 'remote-unobserved' | 'local-source-unbound';
+            strength: 'token' | 'updated-at-and-hash' | 'hash-only' | 'unknown';
+            updatedAt: string | null;
+            observedAt: string | null;
+        };
+    };
+    recovery: Array<{
+        code: string;
+        instruction: string;
+    }>;
+}
+export interface RenderedRemoteCommand {
+    stdout: string;
+    stderr: string;
+    exitCode: 0 | 1 | 2;
+}
+export declare function renderRemoteCommand(envelope: RemoteCommandEnvelope, options: {
+    json: boolean;
+}): RenderedRemoteCommand;
+//# sourceMappingURL=output.d.ts.map

package/dist/commands/pjm/remote/output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"output.d.ts","sourceRoot":"","sources":["../../../../src/commands/pjm/remote/output.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AACvD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAEhD,MAAM,MAAM,mBAAmB,GAC3B,IAAI,GACJ,SAAS,GACT,cAAc,GACd,SAAS,GACT,WAAW,GACX,SAAS,GACT,UAAU,GACV,QAAQ,CAAC;AAEb,MAAM,WAAW,qBAAqB;IACpC,aAAa,EAAE,CAAC,CAAC;IACjB,MAAM,EAAE,mBAAmB,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,OAAO,CAAC;IACnB,OAAO,EAAE,KAAK,CAAC;QACb,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAC;QACvC,MAAM,EAAE,MAAM,CAAC;QACf,MAAM,EAAE,mBAAmB,CAAC;QAC5B,SAAS,EAAE,MAAM,CAAC;QAClB,SAAS,EAAE,MAAM,CAAC;QAClB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;KAC/B,CAAC,CAAC;IACH,cAAc,EAAE,sBAAsB,GAAG,IAAI,CAAC;IAC9C,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;IACxC,eAAe,CAAC,EAAE;QAChB,WAAW,EAAE,MAAM,CAAC;QACpB,MAAM,EAAE,MAAM,CAAC;QACf,cAAc,EAAE,cAAc,CAAC,gBAAgB,CAAC,CAAC;QACjD,SAAS,EAAE,cAAc,CAAC,WAAW,CAAC,CAAC;QACvC,cAAc,EAAE,OAAO,CAAC,cAAc,CAAC,gBAAgB,CAAC,CAAC,CAAC;QAC1D,SAAS,EAAE,MAAM,CAAC;QAClB,gBAAgB,EAAE;YAChB,MAAM,EAAE,MAAM,CAAC;YACf,QAAQ,EAAE,MAAM,CAAC;YACjB,UAAU,EAAE,MAAM,CAAC;YACnB,SAAS,EAAE,MAAM,CAAC;YAClB,MAAM,EAAE,MAAM,CAAC;YACf,UAAU,EAAE,MAAM,CAAC;YACnB,cAAc,EAAE,MAAM,CAAC;SACxB,CAAC;QACF,QAAQ,EAAE;YACR,MAAM,EAAE,MAAM,CAAC;YACf,cAAc,EAAE,MAAM,CAAC;YACvB,MAAM,EAAE,QAAQ,GAAG,mBAAmB,GAAG,sBAAsB,CAAC;YAChE,QAAQ,EAAE,OAAO,GAAG,qBAAqB,GAAG,WAAW,GAAG,SAAS,CAAC;YACpE,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;YACzB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;SAC3B,CAAC;KACH,CAAC;IACF,QAAQ,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACxD;AAED,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;CACrB;AAED,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,qBAAqB,EAC/B,OAAO,EAAE;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,GACzB,qBAAqB,CAyDvB"}

package/dist/commands/pjm/remote/output.js

@@ -0,0 +1,48 @@
+export function renderRemoteCommand(envelope, options) {
+    validateEnvelope(envelope);
+    const exitCode = envelope.status === 'ok' ? 0 : envelope.status === 'failed' ? 2 : 1;
+    if (options.json) {
+        return { stdout: `${JSON.stringify(envelope)}\n`, stderr: '', exitCode };
+    }
+    const lines = [
+        `${envelope.operation}: ${envelope.status}`,
+        `persisted: ${envelope.persisted ? 'yes' : 'no'}`,
+        ...envelope.results.map((result) => `${result.provider} ${result.target} [${result.bindingId}]: ${result.status}; freshness=${result.freshness}; authority=${result.authority}${result.diagnosticCode ? `; code=${result.diagnosticCode}` : ''}`),
+        ...envelope.recovery.map((item) => `recovery ${item.code}: ${item.instruction}`),
+    ];
+    if (envelope.externalAction)
+        lines.push('external action: durable handoff required');
+    if (envelope.discussionEvidence) {
+        lines.push(`discussion evidence: ${envelope.discussionEvidence.status}; items=${envelope.discussionEvidence.items.length}; pages=${envelope.discussionEvidence.pagesRead}; truncated=${String(envelope.discussionEvidence.truncated)}; persisted=${String(envelope.discussionEvidence.persisted)}`);
+        lines.push(...envelope.discussionEvidence.items.map((item) => `discussion item ${item.id}: ${item.body}${item.incomplete ? ' (incomplete)' : ''}`));
+    }
+    if (envelope.approvalPreview) {
+        const preview = envelope.approvalPreview;
+        lines.push(`preview ${preview.operationId}: ${preview.operationClass}; digest=${preview.digest}; fields=${preview.fieldMask.join(',')}; authority=${preview.authority}; revision=${preview.revision.digest}; revision-evidence=${preview.revision.evidenceDigest}; revision-source=${preview.revision.source}; strength=${preview.revision.strength}; updated=${preview.revision.updatedAt ?? 'unobserved'}; observed=${preview.revision.observedAt ?? 'unobserved'}`);
+        lines.push(`components target=${preview.componentDigests.target}; baseline=${preview.componentDigests.baseline}; capability=${preview.componentDigests.capability}; authority=${preview.componentDigests.authority}; policy=${preview.componentDigests.policy}; projection=${preview.componentDigests.projection}; safety=${preview.componentDigests.outboundSafety}`);
+        for (const field of preview.fieldMask) {
+            const rendered = preview.renderedFields[field];
+            if (!rendered) {
+                throw new Error(`Approval preview is missing rendered field '${field}'.`);
+            }
+            lines.push(rendered.kind === 'hash'
+                ? `preview field ${field}: hash=${rendered.digest}; bytes=${rendered.bytes}`
+                : `preview field ${field}: value=${JSON.stringify(rendered.value)}`);
+        }
+    }
+    const rendered = `${lines.join('\n')}\n`;
+    return envelope.status === 'failed'
+        ? { stdout: '', stderr: rendered, exitCode }
+        : { stdout: rendered, stderr: '', exitCode };
+}
+function validateEnvelope(envelope) {
+    if (envelope.schemaVersion !== 1)
+        throw new Error('Unsupported remote command envelope version.');
+    if (envelope.status === 'ok' && !envelope.persisted) {
+        throw new Error('A verified remote outcome must be durably persisted.');
+    }
+    if (envelope.externalAction &&
+        (!envelope.persisted || envelope.status !== 'pending')) {
+        throw new Error('An external action requires a persisted pending handoff.');
+    }
+}

package/dist/commands/pjm/remote/preview.d.ts

@@ -0,0 +1,88 @@
+import type { OatPjmRemoteOperationClass, OatPjmRemoteProvider } from '../../../config/oat-config.js';
+import { type OutboundProjectionSafetyResult } from './outbound-projection-safety.js';
+import type { SharedRemoteField } from './purpose-policy.js';
+export interface BuildBindingPreviewInput {
+    binding: {
+        bindingId: string;
+        provider: OatPjmRemoteProvider;
+        purposes: string[];
+    };
+    target: {
+        stableId: string;
+        context: Record<string, string>;
+    };
+    baseline: {
+        baselineId: string;
+        digest: string;
+    } | null;
+    revision: {
+        strength: string;
+        token: string | null;
+        updatedAt: string | null;
+        contentHash: string;
+    };
+    capability: {
+        surfaceKind: 'connector' | 'configured-cli';
+        evidenceDigest: string;
+        semanticCapabilities: string[];
+        context: Record<string, string>;
+    };
+    policy: Record<string, unknown>;
+    projection: {
+        title: string;
+        description: string | null;
+        priority: string | null;
+    };
+    outboundSafety: OutboundProjectionSafetyResult;
+    operationClass: OatPjmRemoteOperationClass;
+    fieldMask: SharedRemoteField[];
+    createdAt: string;
+}
+type RenderedField = {
+    kind: 'value';
+    value: string | null;
+} | {
+    kind: 'hash';
+    digest: string;
+    bytes: number;
+};
+export interface BindingPreview {
+    schemaVersion: 1;
+    digest: string;
+    bindingId: string;
+    provider: OatPjmRemoteProvider;
+    operationClass: OatPjmRemoteOperationClass;
+    fieldMask: SharedRemoteField[];
+    createdAt: string;
+    componentDigests: {
+        target: string;
+        baseline: string;
+        revision: string;
+        capability: string;
+        policy: string;
+        projection: string;
+        outboundSafety: string;
+    };
+    renderedFields: Record<SharedRemoteField, RenderedField>;
+}
+export interface PreviewApproval {
+    previewDigest: string;
+    operationClass: OatPjmRemoteOperationClass;
+    approvedAt: string;
+    actor: string;
+    source: string;
+}
+export type ApprovalValidationReason = 'digest-mismatch' | 'operation-mismatch' | 'invalid-time' | 'approval-before-preview' | 'future-approval' | 'expired' | 'unsafe-evidence';
+export declare function buildBindingPreview(input: BuildBindingPreviewInput): BindingPreview;
+export declare function validatePreviewApproval(preview: BindingPreview, approval: PreviewApproval, options: {
+    now: string;
+    maxAgeMs: number;
+}): {
+    valid: true;
+    reason: null;
+} | {
+    valid: false;
+    reason: ApprovalValidationReason;
+};
+export {};
+//# sourceMappingURL=preview.d.ts.map

package/dist/commands/pjm/remote/preview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preview.d.ts","sourceRoot":"","sources":["../../../../src/commands/pjm/remote/preview.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,0BAA0B,EAC1B,oBAAoB,EACrB,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EAEL,KAAK,8BAA8B,EACpC,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAG1D,MAAM,WAAW,wBAAwB;IACvC,OAAO,EAAE;QACP,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,oBAAoB,CAAC;QAC/B,QAAQ,EAAE,MAAM,EAAE,CAAC;KACpB,CAAC;IACF,MAAM,EAAE;QACN,QAAQ,EAAE,MAAM,CAAC;QACjB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;KACjC,CAAC;IACF,QAAQ,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IACxD,QAAQ,EAAE;QACR,QAAQ,EAAE,MAAM,CAAC;QACjB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;QACrB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;QACzB,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC;IACF,UAAU,EAAE;QACV,WAAW,EAAE,WAAW,GAAG,gBAAgB,CAAC;QAC5C,cAAc,EAAE,MAAM,CAAC;QACvB,oBAAoB,EAAE,MAAM,EAAE,CAAC;QAC/B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;KACjC,CAAC;IACF,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,UAAU,EAAE;QACV,KAAK,EAAE,MAAM,CAAC;QACd,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;QAC3B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;KACzB,CAAC;IACF,cAAc,EAAE,8BAA8B,CAAC;IAC/C,cAAc,EAAE,0BAA0B,CAAC;IAC3C,SAAS,EAAE,iBAAiB,EAAE,CAAC;IAC/B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,KAAK,aAAa,GACd;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,GACvC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpD,MAAM,WAAW,cAAc;IAC7B,aAAa,EAAE,CAAC,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,oBAAoB,CAAC;IAC/B,cAAc,EAAE,0BAA0B,CAAC;IAC3C,SAAS,EAAE,iBAAiB,EAAE,CAAC;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE;QAChB,MAAM,EAAE,MAAM,CAAC;QACf,QAAQ,EAAE,MAAM,CAAC;QACjB,QAAQ,EAAE,MAAM,CAAC;QACjB,UAAU,EAAE,MAAM,CAAC;QACnB,MAAM,EAAE,MAAM,CAAC;QACf,UAAU,EAAE,MAAM,CAAC;QACnB,cAAc,EAAE,MAAM,CAAC;KACxB,CAAC;IACF,cAAc,EAAE,MAAM,CAAC,iBAAiB,EAAE,aAAa,CAAC,CAAC;CAC1D;AAED,MAAM,WAAW,eAAe;IAC9B,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,0BAA0B,CAAC;IAC3C,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,MAAM,wBAAwB,GAChC,iBAAiB,GACjB,oBAAoB,GACpB,cAAc,GACd,yBAAyB,GACzB,iBAAiB,GACjB,SAAS,GACT,iBAAiB,CAAC;AAQtB,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,wBAAwB,GAC9B,cAAc,CA4ChB;AAED,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,cAAc,EACvB,QAAQ,EAAE,eAAe,EACzB,OAAO,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAExC;IAAE,KAAK,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,IAAI,CAAA;CAAE,GAC7B;IAAE,KAAK,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,wBAAwB,CAAA;CAAE,CA8BrD"}

package/dist/commands/pjm/remote/preview.js

@@ -0,0 +1,154 @@
+import { createHash } from 'node:crypto';
+import { containsSensitiveContentSignal } from './credential-safety.js';
+import { requireCurrentOutboundSafety, } from './outbound-projection-safety.js';
+import { WHOLE_FIELD_SUPPRESSION_MARKER } from './schema.js';
+const FIELD_ORDER = [
+    'title',
+    'description',
+    'priority',
+];
+export function buildBindingPreview(input) {
+    assertTimestamp(input.createdAt, 'preview creation');
+    if (canonicalJson(input.target.context) !==
+        canonicalJson(input.capability.context)) {
+        throw new Error('Preview target and capability contexts must match.');
+    }
+    const fieldMask = normalizeFieldMask(input.fieldMask);
+    requireCurrentOutboundSafety(input.projection, input.outboundSafety);
+    const componentDigests = {
+        target: hashCanonical(input.target),
+        baseline: hashCanonical(input.baseline),
+        revision: hashCanonical(input.revision),
+        capability: hashCanonical(input.capability),
+        policy: hashCanonical(input.policy),
+        projection: input.outboundSafety.projectionDigest,
+        outboundSafety: input.outboundSafety.resultDigest,
+    };
+    const digest = hashCanonical({
+        schemaVersion: 1,
+        binding: input.binding,
+        operationClass: input.operationClass,
+        fieldMask,
+        createdAt: input.createdAt,
+        componentDigests,
+    });
+    return {
+        schemaVersion: 1,
+        digest,
+        bindingId: input.binding.bindingId,
+        provider: input.binding.provider,
+        operationClass: input.operationClass,
+        fieldMask,
+        createdAt: input.createdAt,
+        componentDigests,
+        renderedFields: {
+            title: renderConcise(input.projection.title),
+            description: renderBody(input.projection.description),
+            priority: renderConcise(input.projection.priority),
+        },
+    };
+}
+export function validatePreviewApproval(preview, approval, options) {
+    if (approval.previewDigest !== preview.digest) {
+        return { valid: false, reason: 'digest-mismatch' };
+    }
+    if (approval.operationClass !== preview.operationClass) {
+        return { valid: false, reason: 'operation-mismatch' };
+    }
+    const approvedAt = Date.parse(approval.approvedAt);
+    const previewCreatedAt = Date.parse(preview.createdAt);
+    const now = Date.parse(options.now);
+    if (!Number.isFinite(approvedAt) ||
+        !Number.isFinite(previewCreatedAt) ||
+        !Number.isFinite(now) ||
+        !Number.isFinite(options.maxAgeMs) ||
+        options.maxAgeMs < 0) {
+        return { valid: false, reason: 'invalid-time' };
+    }
+    if (approvedAt < previewCreatedAt) {
+        return { valid: false, reason: 'approval-before-preview' };
+    }
+    if (approvedAt > now)
+        return { valid: false, reason: 'future-approval' };
+    if (now - approvedAt > options.maxAgeMs) {
+        return { valid: false, reason: 'expired' };
+    }
+    if (!isSafeEvidence(approval.actor) || !isSafeEvidence(approval.source)) {
+        return { valid: false, reason: 'unsafe-evidence' };
+    }
+    return { valid: true, reason: null };
+}
+function normalizeFieldMask(fieldMask) {
+    const unique = new Set(fieldMask);
+    if (unique.size !== fieldMask.length || fieldMask.length === 0) {
+        throw new Error('Preview field mask must be non-empty and unique.');
+    }
+    for (const field of unique) {
+        if (!FIELD_ORDER.includes(field)) {
+            throw new Error(`Unsupported preview field '${String(field)}'.`);
+        }
+    }
+    return FIELD_ORDER.filter((field) => unique.has(field));
+}
+function renderConcise(value) {
+    if (value === null)
+        return { kind: 'value', value: null };
+    if (containsSensitiveContentSignal(value)) {
+        return { kind: 'value', value: WHOLE_FIELD_SUPPRESSION_MARKER };
+    }
+    return {
+        kind: 'value',
+        value: value.length > 160 ? `${value.slice(0, 157)}...` : value,
+    };
+}
+function renderBody(value) {
+    if (value === null)
+        return { kind: 'value', value: null };
+    return {
+        kind: 'hash',
+        digest: hashText(value),
+        bytes: Buffer.byteLength(value, 'utf8'),
+    };
+}
+function isSafeEvidence(value) {
+    return (value.length > 0 &&
+        value.length <= 255 &&
+        !/[\r\n]/.test(value) &&
+        !value.includes('\0') &&
+        !containsSensitiveContentSignal(value));
+}
+function hashCanonical(value) {
+    return hashText(canonicalJson(value));
+}
+function hashText(value) {
+    return `sha256:${createHash('sha256').update(value).digest('hex')}`;
+}
+function canonicalJson(value) {
+    return JSON.stringify(canonicalize(value));
+}
+function canonicalize(value) {
+    if (value === null ||
+        typeof value === 'string' ||
+        typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value))
+            throw new Error('Preview inputs must be finite.');
+        return value;
+    }
+    if (Array.isArray(value))
+        return value.map(canonicalize);
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value)
+            .filter(([, entry]) => entry !== undefined)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, entry]) => [key, canonicalize(entry)]));
+    }
+    throw new Error(`Unsupported preview input type '${typeof value}'.`);
+}
+function assertTimestamp(value, label) {
+    if (!Number.isFinite(Date.parse(value))) {
+        throw new Error(`Invalid ${label} time '${value}'.`);
+    }
+}

package/dist/commands/pjm/remote/provider-conformance.d.ts

@@ -0,0 +1,13 @@
+import { type ProviderAdapter, type SanitizedProviderObservation, type SemanticAction } from './provider.js';
+export interface ProviderConformanceFixture {
+    adapter: ProviderAdapter;
+    observation: SanitizedProviderObservation;
+    expected: {
+        stableId: string;
+        aliases: string[];
+        verificationFields: string[];
+    };
+}
+export declare function evaluateProviderConformance(fixture: ProviderConformanceFixture): string[];
+export declare function validateSemanticObservation(action: SemanticAction, observation: SanitizedProviderObservation): string[];
+//# sourceMappingURL=provider-conformance.d.ts.map

package/dist/commands/pjm/remote/provider-conformance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-conformance.d.ts","sourceRoot":"","sources":["../../../../src/commands/pjm/remote/provider-conformance.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,4BAA4B,EACjC,KAAK,cAAc,EACpB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,0BAA0B;IACzC,OAAO,EAAE,eAAe,CAAC;IACzB,WAAW,EAAE,4BAA4B,CAAC;IAC1C,QAAQ,EAAE;QACR,QAAQ,EAAE,MAAM,CAAC;QACjB,OAAO,EAAE,MAAM,EAAE,CAAC;QAClB,kBAAkB,EAAE,MAAM,EAAE,CAAC;KAC9B,CAAC;CACH;AAED,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,0BAA0B,GAClC,MAAM,EAAE,CAkCV;AAED,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,cAAc,EACtB,WAAW,EAAE,4BAA4B,GACxC,MAAM,EAAE,CASV"}