@open-agent-toolkit/cli 0.2.65 → 0.2.66

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

@@ -0,0 +1,224 @@
+import { buildExternalAction, } from './external-action.js';
+import { selectHostExecution, } from './host-execution.js';
+import { requireCurrentOutboundSafety, } from './outbound-projection-safety.js';
+import { validatePreviewApproval } from './preview.js';
+import { semanticDigest, } from './provider.js';
+import { sanitizeRemoteSnapshot, } from './snapshot.js';
+export async function refreshBinding(bindingId, dependencies) {
+    const binding = await requireBinding(bindingId, dependencies.store);
+    const remote = await dependencies.provider.read({
+        provider: binding.provider,
+        context: binding.context,
+    });
+    const snapshot = normalizeSnapshot(binding, remote, dependencies.provider.adapter);
+    await dependencies.store.commitRefresh(binding.bindingId, snapshot);
+    return { status: 'ok', snapshot };
+}
+export async function intakeRemoteIssue(input, dependencies) {
+    const remote = await dependencies.provider.read({
+        provider: input.binding.provider,
+        context: input.binding.context,
+    });
+    const binding = {
+        ...input.binding,
+        snapshot: null,
+        baseline: null,
+    };
+    const snapshot = normalizeSnapshot(binding, remote, dependencies.provider.adapter);
+    const issue = dependencies.provider.adapter.normalize(remote.observation);
+    const baseline = {
+        acceptedAt: dependencies.now(),
+        fields: {
+            title: issue.title,
+            description: issue.description,
+            priority: issue.priority,
+        },
+        localRevision: input.localRevision,
+        remoteRevisionDigest: issue.revisionDigest,
+    };
+    await dependencies.store.commitIntake({
+        binding,
+        snapshot,
+        baseline,
+        mode: input.mode,
+    });
+    return { status: 'ok', snapshot, baseline };
+}
+function normalizeSnapshot(binding, remote, adapter) {
+    if (adapter.provider !== binding.provider)
+        throw new Error('Lifecycle provider adapter mismatch.');
+    const issue = adapter.normalize(remote.observation);
+    if (issue.provider !== binding.provider)
+        throw new Error('Lifecycle observation provider mismatch.');
+    return sanitizeRemoteSnapshot({
+        ...remote.snapshot,
+        bindingId: binding.bindingId,
+        provider: binding.provider,
+        issue: {
+            title: issue.title,
+            description: issue.description ?? '',
+            priority: issue.priority,
+            status: issue.status,
+        },
+    }, { allowedExtensionKeys: remote.allowedExtensionKeys });
+}
+async function requireBinding(bindingId, store) {
+    const binding = await store.readBinding(bindingId);
+    if (!binding)
+        throw new Error(`Remote binding '${bindingId}' does not exist.`);
+    return binding;
+}
+export function baselineRevisionDigest(baseline) {
+    return semanticDigest(baseline);
+}
+export async function publishUnboundBinding(input, dependencies) {
+    return dependencies.createAndBind(input);
+}
+export async function publishBinding(input, dependencies) {
+    requireCurrentOutboundSafety(input.projection, input.outboundSafety);
+    if (input.preview.projectionDigest !== input.outboundSafety.projectionDigest ||
+        input.preview.safetyResultDigest !== input.outboundSafety.resultDigest) {
+        throw new Error('Publish preview safety evidence is stale or mismatched.');
+    }
+    const preRead = await dependencies.preRead({ binding: input.binding });
+    if (preRead.revisionDigest !== input.preview.observedRevisionDigest) {
+        await dependencies.store.markTerminal(input.operationId, 'blocked', semanticDigest(preRead));
+        return { status: 'blocked' };
+    }
+    const [authority, invocation, recomputed] = await Promise.all([
+        dependencies.resolveCurrentAuthority({
+            binding: input.binding,
+            operation: input.operation,
+        }),
+        dependencies.currentInvocation(),
+        dependencies.recomputeAfterPreRead({
+            binding: input.binding,
+            operation: input.operation,
+            revisionDigest: preRead.revisionDigest,
+        }),
+    ]);
+    assertResolvedAuthority(authority, invocation, input, dependencies);
+    requireCurrentOutboundSafety(recomputed.projection, recomputed.outboundSafety);
+    if (semanticDigest(recomputed.projection) !==
+        semanticDigest(input.projection) ||
+        recomputed.outboundSafety.projectionDigest !==
+            input.preview.projectionDigest ||
+        recomputed.outboundSafety.resultDigest !==
+            input.preview.safetyResultDigest ||
+        recomputed.previewDigest !== input.preview.digest ||
+        recomputed.policyDigest !== input.preview.policyDigest) {
+        throw new Error('Mutation projection, safety, preview, or policy drifted after pre-read.');
+    }
+    const selection = selectHostExecution({
+        provider: input.binding.provider,
+        context: input.binding.context,
+        operation: input.operation,
+        candidates: recomputed.capabilityCandidates,
+        attemptStarted: false,
+    });
+    if (!selection.selected)
+        throw new Error(`No current host capability: ${selection.reason}.`);
+    if (selection.evidence.evidenceDigest !== input.preview.capabilityEvidenceDigest) {
+        throw new Error('Host capability evidence drifted before mutation attempt.');
+    }
+    await dependencies.store.persistPlanned({
+        operationId: input.operationId,
+        bindingId: input.binding.bindingId,
+        previewDigest: input.preview.digest,
+        projectionDigest: input.preview.projectionDigest,
+        safetyResultDigest: input.preview.safetyResultDigest,
+        authority,
+    });
+    const action = buildExternalAction({
+        operationId: input.operationId,
+        stepId: input.stepId,
+        provider: input.binding.provider,
+        semanticOperation: input.operation,
+        context: input.binding.context,
+        intent: {
+            stableId: input.binding.snapshot?.identity.stableId ?? null,
+            fields: recomputed.projection,
+        },
+        expectedObservation: {
+            fields: Object.keys(input.projection),
+            requireIdentity: true,
+            stableId: input.binding.snapshot?.identity.stableId ?? null,
+            capabilityEvidenceDigest: selection.evidence.evidenceDigest,
+        },
+        persistedPreview: input.preview,
+        projection: recomputed.projection,
+        outboundSafety: recomputed.outboundSafety,
+    });
+    await dependencies.store.markAttemptStarted(input.operationId, action, selection.evidence);
+    const attempt = await dependencies.execute(action);
+    if (attempt.classification === 'not-committed') {
+        await dependencies.store.markTerminal(input.operationId, 'rejected', attempt.evidenceDigest);
+        return { status: 'rejected', action };
+    }
+    if (attempt.classification === 'unknown') {
+        await dependencies.store.markTerminal(input.operationId, 'uncertain', attempt.evidenceDigest);
+        return { status: 'uncertain', action };
+    }
+    try {
+        const readback = await dependencies.readBack({
+            binding: input.binding,
+            action,
+        });
+        const verified = Object.entries(input.projection).every(([field, value]) => readback.fields[field] === value);
+        const status = verified ? 'verified' : 'uncertain';
+        await dependencies.store.markTerminal(input.operationId, status, semanticDigest(readback));
+        return { status, action };
+    }
+    catch {
+        await dependencies.store.markTerminal(input.operationId, 'uncertain', semanticDigest({ code: 'readback-unavailable' }));
+        return { status: 'uncertain', action };
+    }
+}
+export async function reconcileRemoteBinding(input, dependencies) {
+    if (input.conflicts.length > 0)
+        return { status: 'blocked' };
+    return publishBinding(input, dependencies);
+}
+function assertResolvedAuthority(authority, invocation, input, dependencies) {
+    if (authority.effective === 'read-only')
+        throw new Error('Remote mutation is read-only.');
+    if (authority.effective === 'user-authorized' &&
+        (invocation.kind !== 'interactive' ||
+            invocation.evidenceDigest !== authority.instructionDigest)) {
+        throw new Error('Explicit user instruction does not authorize this mutation.');
+    }
+    if (authority.effective === 'user-approved' &&
+        (!authority.approval ||
+            !validatePreviewApproval({
+                schemaVersion: 1,
+                digest: input.preview.digest,
+                bindingId: input.binding.bindingId,
+                provider: input.binding.provider,
+                operationClass: input.operation === 'create' ? 'create' : 'update-fields',
+                fieldMask: Object.keys(input.projection),
+                createdAt: input.preview.createdAt,
+                componentDigests: {
+                    target: 'persisted',
+                    baseline: 'persisted',
+                    revision: input.preview.observedRevisionDigest,
+                    capability: input.preview.capabilityEvidenceDigest,
+                    policy: input.preview.policyDigest,
+                    projection: input.preview.projectionDigest,
+                    outboundSafety: input.preview.safetyResultDigest,
+                },
+                renderedFields: {
+                    title: { kind: 'hash', digest: 'persisted', bytes: 0 },
+                    description: { kind: 'hash', digest: 'persisted', bytes: 0 },
+                    priority: { kind: 'hash', digest: 'persisted', bytes: 0 },
+                },
+            }, authority.approval, { now: dependencies.now(), maxAgeMs: dependencies.approvalMaxAgeMs }).valid)) {
+        throw new Error('Fresh approval does not match the current preview.');
+    }
+    if (authority.effective === 'autonomous' &&
+        (invocation.kind !== 'workflow' ||
+            !authority.activeWorkflow ||
+            invocation.workflowId !== authority.activeWorkflow.workflowId ||
+            invocation.revision !== authority.activeWorkflow.revision)) {
+        throw new Error('Autonomous mutation requires current active-workflow authority.');
+    }
+}

package/dist/commands/pjm/remote/local-projection.d.ts

@@ -0,0 +1,30 @@
+export interface LocalProjection {
+    title: string;
+    description: string | null;
+    priority: string | null;
+    source: 'backlog-description' | 'explicit-project-publication';
+    sourceRevision: string;
+    observedAt: string;
+}
+interface BacklogProjectionTarget {
+    kind: 'backlog';
+    path: string;
+    content: string;
+}
+interface ProjectPublication {
+    title: string;
+    description: string | null;
+    priority: string | null;
+}
+interface ProjectProjectionTarget {
+    kind: 'project';
+    path: string;
+    publication: ProjectPublication;
+}
+export interface ResolveLocalProjectionInput {
+    target: BacklogProjectionTarget | ProjectProjectionTarget;
+    observedAt: string;
+}
+export declare function resolveLocalProjection(input: ResolveLocalProjectionInput): LocalProjection;
+export {};
+//# sourceMappingURL=local-projection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"local-projection.d.ts","sourceRoot":"","sources":["../../../../src/commands/pjm/remote/local-projection.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,MAAM,EAAE,qBAAqB,GAAG,8BAA8B,CAAC;IAC/D,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,UAAU,uBAAuB;IAC/B,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,UAAU,kBAAkB;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB;AAED,UAAU,uBAAuB;IAC/B,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,kBAAkB,CAAC;CACjC;AAED,MAAM,WAAW,2BAA2B;IAC1C,MAAM,EAAE,uBAAuB,GAAG,uBAAuB,CAAC;IAC1D,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,2BAA2B,GACjC,eAAe,CAcjB"}

package/dist/commands/pjm/remote/local-projection.js

@@ -0,0 +1,95 @@
+import { createHash } from 'node:crypto';
+import { getFrontmatterBlock, parseFrontmatterScalarFields, } from '../../shared/frontmatter.js';
+export function resolveLocalProjection(input) {
+    assertObservedAt(input.observedAt);
+    if (!input.target.path.trim()) {
+        throw new Error('Local projection source path must not be empty.');
+    }
+    if (input.target.kind === 'backlog') {
+        return resolveBacklogProjection(input.target, input.observedAt);
+    }
+    if (input.target.kind === 'project') {
+        return resolveProjectProjection(input.target, input.observedAt);
+    }
+    throw new Error('Unsupported local projection target kind.');
+}
+function resolveBacklogProjection(target, observedAt) {
+    const frontmatter = getFrontmatterBlock(target.content);
+    if (!frontmatter) {
+        throw new Error(`Backlog projection '${target.path}' requires frontmatter.`);
+    }
+    const parsed = parseFrontmatterScalarFields(frontmatter, [
+        'title',
+        'priority',
+    ]);
+    if (!parsed.valid || !parsed.values.title) {
+        throw new Error(`Backlog projection '${target.path}' requires valid frontmatter with one string title.`);
+    }
+    const description = extractDescriptionSection(target.content, target.path);
+    const selected = {
+        targetKind: target.kind,
+        sourcePath: target.path,
+        title: parsed.values.title,
+        description,
+        priority: parsed.values.priority ?? null,
+        source: 'backlog-description',
+    };
+    return {
+        title: selected.title,
+        description: selected.description,
+        priority: selected.priority,
+        source: selected.source,
+        sourceRevision: hashSelectedProjection(selected),
+        observedAt,
+    };
+}
+function resolveProjectProjection(target, observedAt) {
+    const title = target.publication.title.trim();
+    if (!title) {
+        throw new Error('An explicit project publication requires a title.');
+    }
+    const selected = {
+        targetKind: target.kind,
+        sourcePath: target.path,
+        title,
+        description: normalizeOptionalValue(target.publication.description),
+        priority: normalizeOptionalValue(target.publication.priority),
+        source: 'explicit-project-publication',
+    };
+    return {
+        title: selected.title,
+        description: selected.description,
+        priority: selected.priority,
+        source: selected.source,
+        sourceRevision: hashSelectedProjection(selected),
+        observedAt,
+    };
+}
+function extractDescriptionSection(content, sourcePath) {
+    const headings = [...content.matchAll(/^##[ \t]+Description[ \t]*$/gm)];
+    if (headings.length !== 1) {
+        throw new Error(`Backlog projection '${sourcePath}' requires exactly one level-two Description section.`);
+    }
+    const heading = headings[0];
+    const sectionStart = heading.index + heading[0].length;
+    const remaining = content.slice(sectionStart).replace(/^\r?\n/, '');
+    const nextOwnedHeading = /^#{1,2}[ \t]+[^\r\n]+$/m.exec(remaining);
+    const section = (nextOwnedHeading ? remaining.slice(0, nextOwnedHeading.index) : remaining).trim();
+    return section || null;
+}
+function normalizeOptionalValue(value) {
+    if (value === null)
+        return null;
+    const normalized = value.trim();
+    return normalized || null;
+}
+function hashSelectedProjection(value) {
+    return `sha256:${createHash('sha256')
+        .update(JSON.stringify(value))
+        .digest('hex')}`;
+}
+function assertObservedAt(value) {
+    if (!Number.isFinite(Date.parse(value))) {
+        throw new Error(`Invalid projection observation time '${value}'.`);
+    }
+}

package/dist/commands/pjm/remote/managed-markdown.d.ts

@@ -0,0 +1,30 @@
+export type ManagedMarkdownChoiceReason = 'missing-boundary' | 'duplicate-boundary' | 'nested-boundary' | 'malformed-boundary' | 'heading-mismatch';
+export type ManagedMarkdownInspection = {
+    status: 'absent';
+    content: null;
+} | {
+    status: 'managed';
+    content: string;
+    range: {
+        start: number;
+        end: number;
+    };
+} | {
+    status: 'choice-required';
+    reason: Exclude<ManagedMarkdownChoiceReason, 'missing-boundary'>;
+    body: string;
+};
+export type ManagedMarkdownUpdate = {
+    status: 'updated';
+    operation: 'insert' | 'replace';
+    body: string;
+} | {
+    status: 'choice-required';
+    reason: ManagedMarkdownChoiceReason;
+    body: string;
+};
+export declare function buildManagedMarkdownBlock(bindingId: string, content: string): string;
+export declare function inspectManagedMarkdown(body: string, bindingId: string): ManagedMarkdownInspection;
+export declare function insertManagedMarkdown(body: string, bindingId: string, content: string): ManagedMarkdownUpdate;
+export declare function replaceManagedMarkdown(body: string, bindingId: string, content: string): ManagedMarkdownUpdate;
+//# sourceMappingURL=managed-markdown.d.ts.map

package/dist/commands/pjm/remote/managed-markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"managed-markdown.d.ts","sourceRoot":"","sources":["../../../../src/commands/pjm/remote/managed-markdown.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,2BAA2B,GACnC,kBAAkB,GAClB,oBAAoB,GACpB,iBAAiB,GACjB,oBAAoB,GACpB,kBAAkB,CAAC;AAEvB,MAAM,MAAM,yBAAyB,GACjC;IAAE,MAAM,EAAE,QAAQ,CAAC;IAAC,OAAO,EAAE,IAAI,CAAA;CAAE,GACnC;IACE,MAAM,EAAE,SAAS,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC;CACvC,GACD;IACE,MAAM,EAAE,iBAAiB,CAAC;IAC1B,MAAM,EAAE,OAAO,CAAC,2BAA2B,EAAE,kBAAkB,CAAC,CAAC;IACjE,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEN,MAAM,MAAM,qBAAqB,GAC7B;IACE,MAAM,EAAE,SAAS,CAAC;IAClB,SAAS,EAAE,QAAQ,GAAG,SAAS,CAAC;IAChC,IAAI,EAAE,MAAM,CAAC;CACd,GACD;IACE,MAAM,EAAE,iBAAiB,CAAC;IAC1B,MAAM,EAAE,2BAA2B,CAAC;IACpC,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAIN,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,GACd,MAAM,CAGR;AAED,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,GAChB,yBAAyB,CA2D3B;AAED,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,GACd,qBAAqB,CAwBvB;AAED,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,GACd,qBAAqB,CAkBvB"}

package/dist/commands/pjm/remote/managed-markdown.js

@@ -0,0 +1,128 @@
+const ANY_BOUNDARY = /<!-- OAT-MANAGED:[^>\r\n]+:(?:START|END) -->/g;
+export function buildManagedMarkdownBlock(bindingId, content) {
+    assertBindingId(bindingId);
+    return `${startBoundary(bindingId)}\n## OAT-managed\n\n${content}\n${endBoundary(bindingId)}`;
+}
+export function inspectManagedMarkdown(body, bindingId) {
+    assertBindingId(bindingId);
+    const start = startBoundary(bindingId);
+    const end = endBoundary(bindingId);
+    const starts = findAll(body, start);
+    const ends = findAll(body, end);
+    if (starts.length === 0 && ends.length === 0) {
+        return { status: 'absent', content: null };
+    }
+    if (starts.length !== 1 || ends.length !== 1) {
+        return {
+            status: 'choice-required',
+            reason: starts.length > 1 || ends.length > 1
+                ? 'duplicate-boundary'
+                : 'malformed-boundary',
+            body,
+        };
+    }
+    const startIndex = starts[0];
+    const endIndex = ends[0];
+    if (endIndex <= startIndex) {
+        return {
+            status: 'choice-required',
+            reason: 'malformed-boundary',
+            body,
+        };
+    }
+    const innerStart = startIndex + start.length;
+    const inner = body.slice(innerStart, endIndex);
+    if (ANY_BOUNDARY.test(inner)) {
+        ANY_BOUNDARY.lastIndex = 0;
+        return {
+            status: 'choice-required',
+            reason: 'nested-boundary',
+            body,
+        };
+    }
+    ANY_BOUNDARY.lastIndex = 0;
+    const managed = /^\r?\n## OAT-managed[ \t]*\r?\n\r?\n([\s\S]*?)\r?\n$/.exec(inner);
+    if (!managed) {
+        return {
+            status: 'choice-required',
+            reason: 'heading-mismatch',
+            body,
+        };
+    }
+    return {
+        status: 'managed',
+        content: managed[1],
+        range: { start: startIndex, end: endIndex + end.length },
+    };
+}
+export function insertManagedMarkdown(body, bindingId, content) {
+    const inspection = inspectManagedMarkdown(body, bindingId);
+    if (inspection.status !== 'absent') {
+        return {
+            status: 'choice-required',
+            reason: inspection.status === 'managed'
+                ? 'duplicate-boundary'
+                : inspection.reason,
+            body,
+        };
+    }
+    if (containsBoundary(content)) {
+        return { status: 'choice-required', reason: 'nested-boundary', body };
+    }
+    return {
+        status: 'updated',
+        operation: 'insert',
+        body: `${body}${insertionSeparator(body)}${buildManagedMarkdownBlock(bindingId, content)}`,
+    };
+}
+export function replaceManagedMarkdown(body, bindingId, content) {
+    const inspection = inspectManagedMarkdown(body, bindingId);
+    if (inspection.status === 'absent') {
+        return { status: 'choice-required', reason: 'missing-boundary', body };
+    }
+    if (inspection.status === 'choice-required')
+        return inspection;
+    if (containsBoundary(content)) {
+        return { status: 'choice-required', reason: 'nested-boundary', body };
+    }
+    return {
+        status: 'updated',
+        operation: 'replace',
+        body: `${body.slice(0, inspection.range.start)}${buildManagedMarkdownBlock(bindingId, content)}${body.slice(inspection.range.end)}`,
+    };
+}
+function startBoundary(bindingId) {
+    return `<!-- OAT-MANAGED:${bindingId}:START -->`;
+}
+function endBoundary(bindingId) {
+    return `<!-- OAT-MANAGED:${bindingId}:END -->`;
+}
+function findAll(body, value) {
+    const indices = [];
+    let from = 0;
+    while (from <= body.length) {
+        const index = body.indexOf(value, from);
+        if (index === -1)
+            break;
+        indices.push(index);
+        from = index + value.length;
+    }
+    return indices;
+}
+function insertionSeparator(body) {
+    if (body.length === 0 || body.endsWith('\n\n'))
+        return '';
+    if (body.endsWith('\n'))
+        return '\n';
+    return '\n\n';
+}
+function containsBoundary(value) {
+    const found = ANY_BOUNDARY.test(value);
+    ANY_BOUNDARY.lastIndex = 0;
+    return found;
+}
+function assertBindingId(bindingId) {
+    if (!bindingId || /[\r\n:<>]/.test(bindingId)) {
+        throw new Error('Managed Markdown requires a safe binding ID.');
+    }
+}

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

@@ -0,0 +1,14 @@
+export interface RemoteMigrationResult {
+    schemaVersion: 1;
+    mode: 'check' | 'apply';
+    previewDigest: string;
+    changed: boolean;
+    applied: boolean;
+    associatedIssues: unknown[];
+}
+export declare function migrateRemoteAssociations(input: {
+    mode: 'check' | 'apply';
+    associatedIssues: readonly unknown[];
+    approvalDigest?: string;
+}): RemoteMigrationResult;
+//# sourceMappingURL=migrate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"migrate.d.ts","sourceRoot":"","sources":["../../../../src/commands/pjm/remote/migrate.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,qBAAqB;IACpC,aAAa,EAAE,CAAC,CAAC;IACjB,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC;IACxB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,gBAAgB,EAAE,OAAO,EAAE,CAAC;CAC7B;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE;IAC/C,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC;IACxB,gBAAgB,EAAE,SAAS,OAAO,EAAE,CAAC;IACrC,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,GAAG,qBAAqB,CAoBxB"}

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

@@ -0,0 +1,32 @@
+import { semanticDigest } from './provider.js';
+export function migrateRemoteAssociations(input) {
+    const associatedIssues = input.associatedIssues.map(canonicalizeAssociation);
+    const previewDigest = semanticDigest({
+        operation: 'local-remote-association-migration',
+        before: input.associatedIssues,
+        after: associatedIssues,
+    });
+    const changed = JSON.stringify(input.associatedIssues) !== JSON.stringify(associatedIssues);
+    if (input.mode === 'apply' && input.approvalDigest !== previewDigest) {
+        throw new Error('Apply requires the exact approved migration preview.');
+    }
+    return {
+        schemaVersion: 1,
+        mode: input.mode,
+        previewDigest,
+        changed,
+        applied: input.mode === 'apply',
+        associatedIssues,
+    };
+}
+function canonicalizeAssociation(value) {
+    if (typeof value !== 'string')
+        return value;
+    const separator = value.indexOf(':');
+    if (separator <= 0 || separator === value.length - 1)
+        return value;
+    const type = value.slice(0, separator);
+    if (!['github', 'linear', 'jira'].includes(type))
+        return value;
+    return { type, ref: value.slice(separator + 1) };
+}

package/dist/commands/pjm/remote/operation-state.d.ts

@@ -0,0 +1,15 @@
+export declare const OPERATION_STATES: readonly ['planned', 'pending', 'authorized', 'attempt-started', 'verification-pending', 'blocked', 'verified', 'partial', 'uncertain', 'failed', 'rejected'];
+export type OperationState = (typeof OPERATION_STATES)[number];
+export declare function transitionRemoteOperation(current: OperationState, next: OperationState, subject?: 'parent' | 'substep'): OperationState;
+export interface CompositeSubstepState {
+    substepId: string;
+    state: OperationState;
+}
+export interface CompositeOperationStateReduction {
+    state: OperationState;
+    verifiedSubstepIds: string[];
+    continuableSubstepId: string | null;
+    retryDisposition: 'not-applicable' | 'safe-before-attempt' | 'reconcile-required';
+}
+export declare function reduceCompositeOperationState(substeps: readonly CompositeSubstepState[]): CompositeOperationStateReduction;
+//# sourceMappingURL=operation-state.d.ts.map

package/dist/commands/pjm/remote/operation-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operation-state.d.ts","sourceRoot":"","sources":["../../../../src/commands/pjm/remote/operation-state.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,YAC3B,SAAS,EACT,SAAS,EACT,YAAY,EACZ,iBAAiB,EACjB,sBAAsB,EACtB,SAAS,EACT,UAAU,EACV,SAAS,EACT,WAAW,EACX,QAAQ,EACR,UAAU,CACF,CAAC;AAEX,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC;AAuC/D,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,cAAc,EACpB,OAAO,GAAE,QAAQ,GAAG,SAAoB,GACvC,cAAc,CAOhB;AAED,MAAM,WAAW,qBAAqB;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,cAAc,CAAC;CACvB;AAED,MAAM,WAAW,gCAAgC;IAC/C,KAAK,EAAE,cAAc,CAAC;IACtB,kBAAkB,EAAE,MAAM,EAAE,CAAC;IAC7B,oBAAoB,EAAE,MAAM,GAAG,IAAI,CAAC;IACpC,gBAAgB,EACZ,gBAAgB,GAChB,qBAAqB,GACrB,oBAAoB,CAAC;CAC1B;AAED,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,SAAS,qBAAqB,EAAE,GACzC,gCAAgC,CAgFlC"}