@principles/core 1.73.0

package/dist/runtime-v2/internalization/internalization-route.js

@@ -0,0 +1,112 @@
+/**
+ * Internalization Route Model — Maps recommendation kinds to pipeline routes
+ *
+ * PURPOSE: Pure, deterministic mapping from DiagnosticianRecommendation kinds
+ * to internalization pipeline routes. No I/O, no filesystem, no side effects.
+ *
+ * ROUTES:
+ *   principle-ledger          — wisdom/principle write path
+ *   rule-candidate            — rule compilation pipeline (requires trigger + action)
+ *   implementation-candidate  — code implementation pipeline
+ *   prompt-injection-candidate — prompt/skill injection pipeline
+ *   deferred                  — intentionally skipped, never enters executable pipeline
+ */
+// ── Canonical kind-to-route mapping ─────────────────────────────────────────
+const KIND_ROUTE_MAP = Object.create(null);
+KIND_ROUTE_MAP.principle = 'principle-ledger';
+KIND_ROUTE_MAP.rule = 'rule-candidate';
+KIND_ROUTE_MAP.implementation = 'implementation-candidate';
+KIND_ROUTE_MAP.prompt = 'prompt-injection-candidate';
+KIND_ROUTE_MAP.defer = 'deferred';
+// ── Pure decision function ──────────────────────────────────────────────────
+export function decideInternalizationRoute(recommendation) {
+    const route = KIND_ROUTE_MAP[recommendation.kind] ?? 'deferred';
+    // Handle unknown/invalid kinds
+    if (route === 'deferred' && recommendation.kind !== 'defer') {
+        return {
+            ready: false,
+            route,
+            missingFields: [],
+            reason: `Unrecognized recommendation kind "${recommendation.kind}" — deferred to safe default.`,
+            nextAction: 'Review diagnostician output for unsupported recommendation kind.',
+        };
+    }
+    // defer: always not ready, intentionally skips pipeline
+    if (recommendation.kind === 'defer') {
+        return {
+            ready: false,
+            route,
+            missingFields: [],
+            reason: 'Recommendation explicitly deferred — no internalization action required.',
+            nextAction: 'No action needed. Re-evaluate if context changes.',
+        };
+    }
+    // principle: requires abstractedPrinciple
+    if (recommendation.kind === 'principle') {
+        const missingFields = [];
+        if (!recommendation.abstractedPrinciple?.trim()) {
+            missingFields.push('abstractedPrinciple');
+        }
+        return {
+            ready: missingFields.length === 0,
+            route,
+            missingFields,
+            reason: missingFields.length > 0
+                ? `Principle recommendation incomplete: missing ${missingFields.join(', ')}.`
+                : 'Principle recommendation ready for ledger write path.',
+            nextAction: missingFields.length > 0
+                ? 'Re-run diagnostician with PHASE 4 taxonomy to generate abstractedPrinciple.'
+                : 'Proceed with principle-ledger intake.',
+        };
+    }
+    // rule: requires triggerPattern + action
+    if (recommendation.kind === 'rule') {
+        const missingFields = [];
+        if (!recommendation.triggerPattern?.trim()) {
+            missingFields.push('triggerPattern');
+        }
+        if (!recommendation.action?.trim()) {
+            missingFields.push('action');
+        }
+        return {
+            ready: missingFields.length === 0,
+            route,
+            missingFields,
+            reason: missingFields.length > 0
+                ? `Rule recommendation incomplete: missing ${missingFields.join(', ')}.`
+                : 'Rule recommendation ready for candidate pipeline.',
+            nextAction: missingFields.length > 0
+                ? 'Re-run diagnostician with PHASE 4 taxonomy to generate missing rule fields.'
+                : 'Proceed with rule-candidate compilation.',
+        };
+    }
+    // implementation: always ready
+    if (recommendation.kind === 'implementation') {
+        return {
+            ready: true,
+            route,
+            missingFields: [],
+            reason: 'Implementation recommendation ready for candidate pipeline.',
+            nextAction: 'Proceed with implementation-candidate intake and compilation.',
+        };
+    }
+    // prompt: always ready
+    if (recommendation.kind === 'prompt') {
+        return {
+            ready: true,
+            route,
+            missingFields: [],
+            reason: 'Prompt recommendation ready for injection candidate pipeline.',
+            nextAction: 'Proceed with prompt-injection-candidate intake.',
+        };
+    }
+    // Exhaustive fallback — TypeScript ensures this is unreachable for valid kinds
+    return {
+        ready: false,
+        route,
+        missingFields: [],
+        reason: `Unhandled recommendation kind "${recommendation.kind}" — deferred to safe default.`,
+        nextAction: 'Review diagnostician output for unsupported recommendation kind.',
+    };
+}
+//# sourceMappingURL=internalization-route.js.map

package/dist/runtime-v2/internalization/internalization-route.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"internalization-route.js","sourceRoot":"","sources":["../../../src/runtime-v2/internalization/internalization-route.ts"],"names":[],"mappings":"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"}

package/dist/runtime-v2/internalization/internalization-state-machine.d.ts

@@ -0,0 +1,157 @@
+/**
+ * Internalization State Machine (PRI-62)
+ *
+ * Pure decision functions for the Internalization Engine state machine.
+ * These functions return structured proposals — they do NOT mutate store state,
+ * do NOT call PDRuntimeAdapter, and do NOT execute createTask.
+ *
+ * Orchestrator (future PRI-62 scope) is responsible for consuming these
+ * decisions and invoking RuntimeStateManager to apply transitions.
+ *
+ * Key design:
+ *   - Guard functions (task-guards.ts) validate individual conditions
+ *   - State machine functions compose guards into actionable decisions
+ *   - All functions are pure: same inputs → same outputs, no side effects
+ *
+ * @see docs/adr/0003-peer-agent-state-machine-orchestration.md
+ */
+import type { PDTaskStatus, TaskRecord } from '../task-status.js';
+import type { PITaskRecord, PeerRunnerKind, InternalizationChannel, PIArtifact, ArtifactRef } from './peer-runner-contracts.js';
+/**
+ * Decision when evaluating if a task is ready to execute.
+ *
+ *   proceed:            All conditions met — task can be leased and executed
+ *   blocked:            Dependencies not yet satisfied — wait for them
+ *   dependency_failed:   At least one dependency has failed — escalate policy needed
+ */
+export type DependencyGateDecision = 'proceed' | 'blocked' | 'dependency_failed' | 'retry_wait_pending';
+export interface DependencyGateResult {
+    decision: DependencyGateDecision;
+    /** Whether the task is ready to execute (same as decision === 'proceed') */
+    ready: boolean;
+    /** Task IDs that are blocking execution (status != succeeded) */
+    blockedBy: string[];
+    /** Task IDs that have failed — for escalation policy decision */
+    failedDependencies: string[];
+    /** For retry_wait_pending: ISO timestamp when the task can be retried */
+    retryAfter?: string;
+}
+export interface TransitionValidation {
+    valid: boolean;
+    /** Human-readable reason if invalid */
+    reason?: string;
+}
+/**
+ * Action to take when an artifact has been rejected.
+ *
+ *   create_corrective_task: Re-run the same or corrective runner kind
+ *   escalate:               Human review needed
+ */
+export type RejectionFeedbackAction = 'create_corrective_task' | 'escalate';
+/**
+ * Discriminated union for artifact rejection feedback.
+ *
+ * create_corrective_task: correctiveTaskKind is required
+ * escalate: correctiveTaskKind is absent
+ */
+export type RejectionFeedbackResult = {
+    action: 'create_corrective_task';
+    correctiveTaskKind: PeerRunnerKind;
+    rejectedArtifactId: string;
+    sourceTaskId: string;
+    sourceTaskKind: PeerRunnerKind;
+    rejectionReason?: string;
+} | {
+    action: 'escalate';
+    rejectedArtifactId: string;
+    sourceTaskId: string;
+    sourceTaskKind: PeerRunnerKind;
+    rejectionReason?: string;
+};
+export interface NextTaskProposal {
+    taskKind: PeerRunnerKind;
+    parentTaskId: string;
+    dependencyTaskIds: string[];
+    inputArtifactRefs: ArtifactRef[];
+    channel: InternalizationChannel;
+    correlationId?: string;
+}
+export type GraphErrorType = 'cycle' | 'disallowed_edge' | 'missing_dependency';
+export interface GraphValidationError {
+    type: GraphErrorType;
+    message: string;
+    taskId?: string;
+    fromKind?: string;
+    toKind?: string;
+}
+export interface GraphValidationResult {
+    valid: boolean;
+    errors: GraphValidationError[];
+}
+/**
+ * Validates whether a task is ready to be leased and executed.
+ *
+ * Combines:
+ *   1. canAcquireLease — task status must be pending or retry_wait
+ *   2. areDependenciesMet — all dependencyTaskIds must be succeeded
+ *
+ * Note: dependency failure (dependency_failed) does NOT automatically fail
+ * the dependent task. The escalation policy (PRI-62 follow-up) decides
+ * how to handle dependency failures.
+ */
+export declare function validateInternalizationTaskReady(task: PITaskRecord, dependencies: readonly TaskRecord[], nowMs?: number): DependencyGateResult;
+/**
+ * Validates whether a task status transition is permitted.
+ *
+ * Uses canTransitionTo internally and adds human-readable reasons
+ * for invalid transitions.
+ */
+export declare function validateTaskTransition(task: PITaskRecord, newStatus: PDTaskStatus): TransitionValidation;
+/**
+ * Decides what action to take when an artifact has been rejected.
+ *
+ * Per ADR-0003 Section 3.7 rejection feedback loop:
+ *   - Artifact rejected ≠ task failed (they are separate concerns)
+ *   - Rejected artifacts can generate corrective task proposals
+ *   - Scribe/Artificer rejections → corrective task (re-run)
+ *   - Other runners → escalate for human review
+ *
+ * This function returns a proposal; the Orchestrator decides whether
+ * to act on it.
+ */
+export declare function decideArtifactRejectionFeedback(artifact: PIArtifact, task: PITaskRecord): RejectionFeedbackResult;
+/**
+ * Proposes the next task in the pipeline after a task succeeds.
+ *
+ * Uses the job graph (getAllowedSuccessors) to determine valid next steps:
+ *   - dreamer → philosopher
+ *   - philosopher → scribe
+ *   - scribe → artificer
+ *   - artificer → evaluator
+ *   - evaluator → rollout_reviewer
+ *   - rollout_reviewer → trainer (model_training channel only, v1 terminal successor)
+ *
+ * Requires currentTask.status === 'succeeded' — non-terminal tasks
+ * must not generate successor proposals (prevents pipeline乱序).
+ *
+ * Filters successors by channel constraint: a runner kind transition
+ * is only valid when validateEdge(fromKind, toKind, channel) is true.
+ * For example, rollout_reviewer → trainer requires channel === 'model_training'.
+ *
+ * Returns null if the task is not succeeded or no channel-valid
+ * successors exist.
+ */
+export declare function createNextTaskProposal(currentTask: PITaskRecord, _artifacts: PIArtifact[], channel?: InternalizationChannel): NextTaskProposal | null;
+/**
+ * Validates an entire task graph for structural correctness.
+ *
+ * Checks:
+ *   1. No cycles — uses isAcyclic() on extracted edges
+ *   2. All edges are in ALLOWED_EDGES (via validateEdge)
+ *   3. All dependencyTaskIds reference existing tasks (fail closed)
+ *
+ * Note: this does NOT check dependency status (use validateInternalizationTaskReady
+ * for that) — only structural validity.
+ */
+export declare function validateInternalizationGraph(tasks: PITaskRecord[]): GraphValidationResult;
+//# sourceMappingURL=internalization-state-machine.d.ts.map

package/dist/runtime-v2/internalization/internalization-state-machine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internalization-state-machine.d.ts","sourceRoot":"","sources":["../../../src/runtime-v2/internalization/internalization-state-machine.ts"],"names":[],"mappings":"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"}

package/dist/runtime-v2/internalization/internalization-state-machine.js

@@ -0,0 +1,274 @@
+/**
+ * Internalization State Machine (PRI-62)
+ *
+ * Pure decision functions for the Internalization Engine state machine.
+ * These functions return structured proposals — they do NOT mutate store state,
+ * do NOT call PDRuntimeAdapter, and do NOT execute createTask.
+ *
+ * Orchestrator (future PRI-62 scope) is responsible for consuming these
+ * decisions and invoking RuntimeStateManager to apply transitions.
+ *
+ * Key design:
+ *   - Guard functions (task-guards.ts) validate individual conditions
+ *   - State machine functions compose guards into actionable decisions
+ *   - All functions are pure: same inputs → same outputs, no side effects
+ *
+ * @see docs/adr/0003-peer-agent-state-machine-orchestration.md
+ */
+import { getAllowedSuccessors, isAcyclic, validateEdge } from './internalization-job-graph.js';
+import { canAcquireLease, canTransitionTo, canRetryNow, isUnresolvable, } from './internalization-task-guards.js';
+// ── Core Decision Functions ──────────────────────────────────────────────────
+/**
+ * Validates whether a task is ready to be leased and executed.
+ *
+ * Combines:
+ *   1. canAcquireLease — task status must be pending or retry_wait
+ *   2. areDependenciesMet — all dependencyTaskIds must be succeeded
+ *
+ * Note: dependency failure (dependency_failed) does NOT automatically fail
+ * the dependent task. The escalation policy (PRI-62 follow-up) decides
+ * how to handle dependency failures.
+ */
+export function validateInternalizationTaskReady(task, dependencies, nowMs) {
+    const blockedBy = [];
+    const failedDependencies = [];
+    // Check if task status allows leasing
+    if (!canAcquireLease(task)) {
+        // Task is already leased, succeeded, or failed — blocked
+        return {
+            decision: 'blocked',
+            ready: false,
+            blockedBy: [],
+            failedDependencies: [],
+        };
+    }
+    // Check if retry_wait backoff period has expired
+    if (!canRetryNow(task, nowMs)) {
+        return {
+            decision: 'retry_wait_pending',
+            ready: false,
+            blockedBy: [],
+            failedDependencies: [],
+            retryAfter: task.leaseExpiresAt,
+        };
+    }
+    // Collect dependency statuses
+    const depMap = new Map(dependencies.map(d => [d.taskId, d]));
+    for (const depId of task.dependencyTaskIds) {
+        const dep = depMap.get(depId);
+        if (!dep) {
+            // Dependency not found — fail closed
+            blockedBy.push(depId);
+        }
+        else if (dep.status === 'succeeded') {
+            // OK
+        }
+        else if (dep.status === 'failed') {
+            failedDependencies.push(depId);
+        }
+        else {
+            blockedBy.push(depId);
+        }
+    }
+    // Determine decision
+    if (failedDependencies.length > 0) {
+        return {
+            decision: 'dependency_failed',
+            ready: false,
+            blockedBy,
+            failedDependencies,
+        };
+    }
+    if (blockedBy.length > 0) {
+        return {
+            decision: 'blocked',
+            ready: false,
+            blockedBy,
+            failedDependencies: [],
+        };
+    }
+    return {
+        decision: 'proceed',
+        ready: true,
+        blockedBy: [],
+        failedDependencies: [],
+    };
+}
+/**
+ * Validates whether a task status transition is permitted.
+ *
+ * Uses canTransitionTo internally and adds human-readable reasons
+ * for invalid transitions.
+ */
+export function validateTaskTransition(task, newStatus) {
+    if (canTransitionTo(task.status, newStatus)) {
+        return { valid: true };
+    }
+    const reason = (() => {
+        if (task.status === 'succeeded' || task.status === 'failed') {
+            return `Terminal state: ${task.status} cannot transition to ${newStatus}`;
+        }
+        if (newStatus === 'succeeded' && task.status !== 'leased') {
+            return `Cannot transition directly to succeeded: task must be leased first (currently ${task.status})`;
+        }
+        if (task.status === 'pending' && newStatus !== 'leased') {
+            return `Pending task can only transition to leased (not ${newStatus})`;
+        }
+        return `Invalid transition from ${task.status} to ${newStatus}`;
+    })();
+    return { valid: false, reason };
+}
+/**
+ * Decides what action to take when an artifact has been rejected.
+ *
+ * Per ADR-0003 Section 3.7 rejection feedback loop:
+ *   - Artifact rejected ≠ task failed (they are separate concerns)
+ *   - Rejected artifacts can generate corrective task proposals
+ *   - Scribe/Artificer rejections → corrective task (re-run)
+ *   - Other runners → escalate for human review
+ *
+ * This function returns a proposal; the Orchestrator decides whether
+ * to act on it.
+ */
+export function decideArtifactRejectionFeedback(artifact, task) {
+    const base = {
+        rejectedArtifactId: artifact.artifactId,
+        sourceTaskId: artifact.sourceTaskId,
+        sourceTaskKind: task.taskKind,
+    };
+    if (isUnresolvable(task)) {
+        return {
+            ...base,
+            action: 'escalate',
+            rejectionReason: 'unresolvable_threshold_exceeded',
+        };
+    }
+    if (task.taskKind === 'scribe') {
+        return {
+            ...base,
+            action: 'create_corrective_task',
+            correctiveTaskKind: 'scribe',
+        };
+    }
+    if (task.taskKind === 'artificer') {
+        return {
+            ...base,
+            action: 'create_corrective_task',
+            correctiveTaskKind: 'artificer',
+        };
+    }
+    return {
+        ...base,
+        action: 'escalate',
+    };
+}
+/**
+ * Proposes the next task in the pipeline after a task succeeds.
+ *
+ * Uses the job graph (getAllowedSuccessors) to determine valid next steps:
+ *   - dreamer → philosopher
+ *   - philosopher → scribe
+ *   - scribe → artificer
+ *   - artificer → evaluator
+ *   - evaluator → rollout_reviewer
+ *   - rollout_reviewer → trainer (model_training channel only, v1 terminal successor)
+ *
+ * Requires currentTask.status === 'succeeded' — non-terminal tasks
+ * must not generate successor proposals (prevents pipeline乱序).
+ *
+ * Filters successors by channel constraint: a runner kind transition
+ * is only valid when validateEdge(fromKind, toKind, channel) is true.
+ * For example, rollout_reviewer → trainer requires channel === 'model_training'.
+ *
+ * Returns null if the task is not succeeded or no channel-valid
+ * successors exist.
+ */
+export function createNextTaskProposal(currentTask, _artifacts, channel) {
+    if (currentTask.status !== 'succeeded') {
+        return null;
+    }
+    if (isUnresolvable(currentTask)) {
+        return null;
+    }
+    const effectiveChannel = channel ?? currentTask.channel;
+    const successors = getAllowedSuccessors(currentTask.taskKind);
+    // Filter to only channel-valid successors (M1: prevent invalid trainer proposal)
+    const validSuccessors = successors.filter(s => validateEdge(currentTask.taskKind, s, effectiveChannel));
+    if (validSuccessors.length === 0) {
+        return null;
+    }
+    // V1: take the first valid successor (linear chain)
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const nextKind = validSuccessors[0];
+    return {
+        taskKind: nextKind,
+        parentTaskId: currentTask.taskId,
+        dependencyTaskIds: [currentTask.taskId],
+        // Defensive copy: prevent caller from mutating source task outputArtifactRefs (M2)
+        inputArtifactRefs: [...currentTask.outputArtifactRefs],
+        channel: effectiveChannel,
+        correlationId: currentTask.correlationId,
+    };
+}
+/**
+ * Validates an entire task graph for structural correctness.
+ *
+ * Checks:
+ *   1. No cycles — uses isAcyclic() on extracted edges
+ *   2. All edges are in ALLOWED_EDGES (via validateEdge)
+ *   3. All dependencyTaskIds reference existing tasks (fail closed)
+ *
+ * Note: this does NOT check dependency status (use validateInternalizationTaskReady
+ * for that) — only structural validity.
+ */
+export function validateInternalizationGraph(tasks) {
+    const errors = [];
+    const taskMap = new Map(tasks.map(t => [t.taskId, t]));
+    // Build dependency edges for cycle detection
+    const edgesForCycle = [];
+    for (const task of tasks) {
+        for (const depId of task.dependencyTaskIds) {
+            const dep = taskMap.get(depId);
+            if (dep) {
+                edgesForCycle.push([depId, task.taskId]);
+            }
+        }
+    }
+    // Check 1: cycles (using isAcyclic on dependency edges)
+    if (!isAcyclic(edgesForCycle)) {
+        errors.push({
+            type: 'cycle',
+            message: 'Task graph contains a cycle — dependencies cannot be satisfied',
+        });
+    }
+    // Check 2: disallowed edges (using validateEdge on runner kind transitions)
+    for (const task of tasks) {
+        for (const depId of task.dependencyTaskIds) {
+            const dep = taskMap.get(depId);
+            if (!dep) {
+                errors.push({
+                    type: 'missing_dependency',
+                    message: `Task ${task.taskId} depends on ${depId} which does not exist in the graph`,
+                    taskId: task.taskId,
+                });
+                continue;
+            }
+            // Use the current task's channel for edge validation
+            const edgeValid = validateEdge(dep.taskKind, task.taskKind, task.channel);
+            if (!edgeValid) {
+                errors.push({
+                    type: 'disallowed_edge',
+                    message: `Disallowed edge: ${dep.taskKind} → ${task.taskKind}`,
+                    taskId: task.taskId,
+                    fromKind: dep.taskKind,
+                    toKind: task.taskKind,
+                });
+            }
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}
+//# sourceMappingURL=internalization-state-machine.js.map

package/dist/runtime-v2/internalization/internalization-state-machine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"internalization-state-machine.js","sourceRoot":"","sources":["../../../src/runtime-v2/internalization/internalization-state-machine.ts"],"names":[],"mappings":"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"}

package/dist/runtime-v2/internalization/internalization-task-guards.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Internalization Task Guards (PRI-62)
+ *
+ * Pure Boolean guard functions that validate individual conditions
+ * for the Internalization Engine state machine.
+ *
+ * Key constraints (ADR-0003 Section 3.9):
+ *   - Terminal task states: succeeded and failed only
+ *   - resultRef is immutable only after status transitions to succeeded
+ *   - lastError can be updated during retry_wait and failed transitions
+ *   - dependencyTaskIds gating must fail closed
+ *
+ * @see docs/adr/0003-peer-agent-state-machine-orchestration.md
+ */
+import type { PDTaskStatus, TaskRecord } from '../task-status.js';
+import type { PITaskRecord, PIArtifact } from './peer-runner-contracts.js';
+/**
+ * Returns true if a retry_wait task's backoff period has expired and it can
+ * be re-leased now.
+ *
+ * When a task enters retry_wait, recovery-sweep sets leaseExpiresAt to
+ * now + backoffMs (the "retry-after" deadline). The task should NOT be
+ * re-leased until that deadline has passed.
+ *
+ * For non-retry_wait tasks, always returns true (no backoff gating needed).
+ *
+ * @param task - The task record to evaluate
+ * @param nowMs - Current time in milliseconds (default: Date.now())
+ */
+export declare function canRetryNow(task: PITaskRecord, nowMs?: number): boolean;
+/**
+ * Returns true if the task status allows acquiring a lease.
+ *
+ * Only `pending` and `retry_wait` can be leased:
+ *   - pending: task is waiting for a runner to pick it up
+ *   - retry_wait: task is recovering after a transient failure
+ *
+ * Terminal states (succeeded/failed) are not leaseable.
+ * `leased` tasks already have an active lease and cannot be re-leased.
+ *
+ * Note: This does NOT check backoff timing. Use canRetryNow() to gate
+ * retry_wait tasks whose backoff period has not yet expired.
+ */
+export declare function canAcquireLease(task: PITaskRecord): boolean;
+/**
+ * Returns true if ALL dependency tasks have reached succeeded state.
+ *
+ * Fail-closed: if ANY dependency is not found in the dependencies array,
+ * or is not in succeeded state, returns false.
+ *
+ * Empty dependencyTaskIds means no gating — returns true.
+ */
+export declare function areDependenciesMet(task: PITaskRecord, dependencies: readonly TaskRecord[]): boolean;
+/**
+ * Returns true if a PDTaskStatus transition is valid per ADR-0003 Section 3.8.
+ *
+ * Valid transitions:
+ *   pending     → leased
+ *   leased      → succeeded
+ *   leased      → retry_wait
+ *   leased      → failed
+ *   leased      → pending   (lease release / force-expire — e.g. LeaseManager.releaseLease)
+ *   retry_wait  → pending   (recovery sweep resets)
+ *
+ * Terminal states (succeeded, failed) cannot transition to any other state.
+ */
+export declare function canTransitionTo(currentStatus: PDTaskStatus, newStatus: PDTaskStatus): boolean;
+/**
+ * Returns true if resultRef is now immutable (task reached succeeded).
+ *
+ * Per ADR-0003: resultRef becomes immutable after task enters succeeded state.
+ * Before succeeded, resultRef may still be set or updated.
+ */
+export declare function isResultRefImmutable(task: PITaskRecord): boolean;
+/**
+ * Returns true if lastError can be updated for this task.
+ *
+ * lastError can be updated during retry_wait and failed transitions.
+ * It is NOT updated during pending (no error yet) or succeeded (terminal).
+ */
+export declare function canUpdateLastError(task: PITaskRecord): boolean;
+/**
+ * Returns true if the artifact has been rejected by the evaluator.
+ *
+ * Per ADR-0003 Section 3.7: rejected artifacts trigger a corrective feedback
+ * loop but do NOT directly set the source task to failed.
+ */
+export declare function isArtifactRejected(artifact: PIArtifact): boolean;
+export declare const DEFAULT_UNRESOLVABLE_THRESHOLD = 3;
+export declare function isUnresolvable(task: PITaskRecord, threshold?: number): boolean;
+export declare function recordRejection(task: PITaskRecord): PITaskRecord;
+//# sourceMappingURL=internalization-task-guards.d.ts.map

package/dist/runtime-v2/internalization/internalization-task-guards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internalization-task-guards.d.ts","sourceRoot":"","sources":["../../../src/runtime-v2/internalization/internalization-task-guards.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAClE,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAI3E;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,YAAY,EAAE,KAAK,GAAE,MAAmB,GAAG,OAAO,CAMnF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAE3D;AAID;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,YAAY,EAClB,YAAY,EAAE,SAAS,UAAU,EAAE,GAClC,OAAO,CAeT;AAID;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,aAAa,EAAE,YAAY,EAAE,SAAS,EAAE,YAAY,GAAG,OAAO,CAmB7F;AAID;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAEhE;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAE9D;AAID;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,UAAU,GAAG,OAAO,CAEhE;AAID,eAAO,MAAM,8BAA8B,IAAI,CAAC;AAEhD,wBAAgB,cAAc,CAAC,IAAI,EAAE,YAAY,EAAE,SAAS,GAAE,MAAuC,GAAG,OAAO,CAG9G;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,YAAY,GAAG,YAAY,CAOhE"}