intentdna 1.7.5 → 1.8.1

package/dist/compiler/cascade.js

@@ -109,15 +109,10 @@ function prefixRecordKeys(record, ns) {
 function prefixController(controller, ns) {
     return {
         ...controller,
-        diagnosis_workflow: `${ns}_${controller.diagnosis_workflow}`,
-        fix_workflow: `${ns}_${controller.fix_workflow}`,
-        roles: {
-            analyzer: `${ns}_${controller.roles.analyzer}`,
-            analysis_reviewer: `${ns}_${controller.roles.analysis_reviewer}`,
-            surgeon: `${ns}_${controller.roles.surgeon}`,
-            fix_reviewer: `${ns}_${controller.roles.fix_reviewer}`,
-            test_runner: `${ns}_${controller.roles.test_runner}`,
-        },
+        workflow: controller.workflow ? `${ns}_${controller.workflow}` : undefined,
+        diagnosis_workflow: controller.diagnosis_workflow ? `${ns}_${controller.diagnosis_workflow}` : undefined,
+        fix_workflow: controller.fix_workflow ? `${ns}_${controller.fix_workflow}` : undefined,
+        roles: Object.fromEntries(Object.entries(controller.roles).map(([roleKey, roleName]) => [roleKey, `${ns}_${roleName}`])),
     };
 }
 function prefixLegibilityAssets(map, ns) {

package/dist/compiler/compile.js

@@ -384,6 +384,7 @@ export function compileDNA(activated, cascaded) {
             workflowsIR.push({
                 workflow_name: wfKey,
                 namespace,
+                step_ids: (wf.steps ?? []).map((step) => step.id),
                 step_checkpoints: wfStepCheckpoints,
                 active_roles: activeRoles,
                 handoff_chain: handoffChain,

package/dist/governance/evidence-capture-attribution.d.ts

@@ -0,0 +1,12 @@
+import type { ConstraintIR } from "../schema/types.js";
+export interface EvidenceCaptureAttributionHint {
+    workflowAsset?: string;
+    workflowId?: string;
+    stepId?: string;
+}
+export interface TrustedEvidenceCaptureAttribution {
+    workflowAsset: string;
+    workflowId: string;
+    stepId: string;
+}
+export declare function trustedEvidenceCaptureAttribution(ir: ConstraintIR, hint: EvidenceCaptureAttributionHint): TrustedEvidenceCaptureAttribution;

package/dist/governance/evidence-capture-attribution.js

@@ -0,0 +1,46 @@
+const UNKNOWN_ATTRIBUTION = "unknown";
+function canonicalWorkflowAsset(ir) {
+    const sourceIds = [...new Set(ir.source_dna_ids)]
+        .filter((sourceId) => sourceId.length > 0)
+        .filter((sourceId) => !sourceId.startsWith("species:"))
+        .filter((sourceId) => !sourceId.startsWith("enterprise:"));
+    return sourceIds.length === 1 ? sourceIds[0] : undefined;
+}
+function attributedWorkflow(ir, workflowId) {
+    if (workflowId) {
+        return ir.workflows_ir?.find((workflow) => workflow.workflow_name === workflowId);
+    }
+    return ir.workflows_ir?.length === 1 ? ir.workflows_ir[0] : undefined;
+}
+function workflowStepIds(ir, workflow) {
+    return new Set([
+        ...(workflow.step_ids ?? []),
+        ...workflow.step_checkpoints.map((checkpoint) => checkpoint.step_id),
+        ...workflow.handoff_chain.map((handoff) => handoff.step_id),
+        ...(workflow.step_enforce_rules ?? []).map((rule) => rule.step_id),
+        ...(ir.verifier_specs ?? [])
+            .filter((spec) => spec.workflow_name === workflow.workflow_name)
+            .map((spec) => spec.step_id)
+            .filter((stepId) => typeof stepId === "string"),
+    ]);
+}
+export function trustedEvidenceCaptureAttribution(ir, hint) {
+    const workflow = attributedWorkflow(ir, hint.workflowId);
+    const invalidExplicitWorkflow = Boolean(hint.workflowId && !workflow);
+    if (invalidExplicitWorkflow) {
+        return {
+            workflowAsset: UNKNOWN_ATTRIBUTION,
+            workflowId: UNKNOWN_ATTRIBUTION,
+            stepId: UNKNOWN_ATTRIBUTION,
+        };
+    }
+    const canonicalAsset = canonicalWorkflowAsset(ir);
+    const workflowAsset = canonicalAsset
+        ? hint.workflowAsset === canonicalAsset ? hint.workflowAsset : canonicalAsset
+        : UNKNOWN_ATTRIBUTION;
+    const workflowId = workflow?.workflow_name ?? UNKNOWN_ATTRIBUTION;
+    const stepId = workflow && hint.stepId && workflowStepIds(ir, workflow).has(hint.stepId)
+        ? hint.stepId
+        : UNKNOWN_ATTRIBUTION;
+    return { workflowAsset, workflowId, stepId };
+}

package/dist/governance/index.d.ts

@@ -5,4 +5,6 @@
  */
 export type { AuditReport, RemoteDNAPolicy, PolicyContent, PolicyScope, PolicyUpdate, GovernanceConfig, GovernanceClient, GovernanceResponse, GovernanceSubscription, } from "./types.js";
 export { CASCADE_LAYER_NAMES, RUNTIME_DECISION_EVENT_SCHEMA_VERSION, validateRuntimeDecisionEvent, } from "./runtime-decision-event.js";
+export { trustedEvidenceCaptureAttribution } from "./evidence-capture-attribution.js";
+export type { EvidenceCaptureAttributionHint, TrustedEvidenceCaptureAttribution, } from "./evidence-capture-attribution.js";
 export type { CascadeDecisionTrace, CascadeLayerFingerprint, CascadeLayerName, CascadeLayers, EnforcementPoint, ExplicitPlaceholder, HarnessRuntimeContext, PolicyBundle, RuntimeDecision, RuntimeDecisionEvent, RuntimeDecisionEventValidationResult, RuntimeEvidenceRef, WinningConstraint, } from "./runtime-decision-event.js";

package/dist/governance/index.js

@@ -4,3 +4,4 @@
  * Exports the v1.7.1 enterprise evidence contract plus reserved remote governance interfaces.
  */
 export { CASCADE_LAYER_NAMES, RUNTIME_DECISION_EVENT_SCHEMA_VERSION, validateRuntimeDecisionEvent, } from "./runtime-decision-event.js";
+export { trustedEvidenceCaptureAttribution } from "./evidence-capture-attribution.js";

package/dist/hooks/cli.d.ts

@@ -49,6 +49,9 @@ export interface RunHookEventOptions {
 }
 export declare function normalizeHookOutputForEvent(output: HookOutput, event: HookEvent): HookOutput;
 export declare function runHookEvent(options: RunHookEventOptions): Promise<HookOutput>;
+export declare function codexHookEventForInput(rawInput: Record<string, unknown>, args: string[]): unknown;
+declare function inferWorkflowAssetFromIr(ir: ConstraintIR, workflowId?: string): string | undefined;
+declare function runCodexHookWithLoadedIr(rawInput: Record<string, unknown>, projectDir: string, args: string[], ir: ConstraintIR): Promise<import("../runtime/codex-adapter.js").CodexHookRunnerResult>;
 declare function recordProducedArtifacts(projectDir: string, ir: ConstraintIR, wfState: {
     workflow: string;
     current_step: string;
@@ -87,6 +90,8 @@ declare function finalizeAndResolveArtifactsForHook(projectDir: string, ir: Cons
 export declare const recordProducedArtifactsForTest: typeof recordProducedArtifacts;
 export declare const resolveWorkflowArtifactFactsForTest: typeof resolveWorkflowArtifactFacts;
 export declare const readWorkflowStateForHookTest: typeof readWorkflowStateForHook;
+export declare const runCodexHookWithLoadedIrForTest: typeof runCodexHookWithLoadedIr;
+export declare const inferWorkflowAssetFromIrForTest: typeof inferWorkflowAssetFromIr;
 export declare const resolveWorkflowArtifactFactsForHookTest: typeof resolveWorkflowArtifactFactsForHook;
 export declare const finalizeAndResolveArtifactsForHookTest: typeof finalizeAndResolveArtifactsForHook;
 export declare function appendStopVerifierWarnings(output: HookOutput, verifierResults: VerifierResultEntry[], currentStep?: string): HookOutput;
@@ -94,6 +99,8 @@ export declare function runVerifiersForTest(projectDir: string, ir: ConstraintIR
     workflow: string;
     current_step: string;
     current_role: string;
+    inputs?: Record<string, string>;
+    resolved_variables?: Record<string, string>;
 }, when: VerifierSpec["when"], sessionId?: string, options?: {
     commandTimeoutMs?: number;
 }): Promise<VerifierResultEntry[]>;
@@ -101,6 +108,8 @@ export declare function runStopVerifiersForTest(projectDir: string, ir: Constrai
     workflow: string;
     current_step: string;
     current_role: string;
+    inputs?: Record<string, string>;
+    resolved_variables?: Record<string, string>;
 }, sessionId?: string, options?: {
     commandTimeoutMs?: number;
 }): Promise<VerifierResultEntry[]>;