agentera 3.0.0-dev.41 → 3.0.0-dev.46

package/dist/state/write/runtimeOperations.js

@@ -1,10 +1,11 @@
 import { loadTodoReadinessContract } from "../../registries/todoReadinessContract.js";
+import { CANONICAL_DEVELOPMENT_CLI } from "../../core/developmentChannel.js";
 export const RUNTIME_WRITABLE_ARTIFACTS = [
     "progress", "decisions", "plan", "health", "objective", "experiments", "todo", "docs", "glossary",
 ];
 export const RUNTIME_WRITE_VERBS = [
     "append", "update", "amend", "set-status", "supersede", "set-plan-status",
-    "record-evaluation", "archive", "create", "publish", "set-severity", "resolve", "reopen", "explain",
+    "record-evaluation", "archive", "create", "publish", "activate", "repair", "set-severity", "resolve", "reopen", "explain",
 ];
 const readiness = loadTodoReadinessContract();
 const f = (flag, field, kind, options = {}) => ({ flag, field, kind, required: false, ...options });
@@ -29,7 +30,7 @@ const planEvaluationFields = [
 const op = (artifact, verb, fields, options = {}) => ({
     artifact, verb, fields, selectors: [], ownedFields: [], inputMode: "none", inputSources: [], structuredInputSources: [], cliOwnedFields: [], inputMaxBytes: 0, allowForce: false, compacts: false, ...options,
 });
-const RUNTIME_OPERATIONS = [
+const RUNTIME_OPERATION_CORES = [
     op("progress", "append", [], { ownedFields: ["id", "artifact", "publication_order"], inputMode: "structured", inputRoot: "one progress cycle record", inputSources: ["file", "stdin"], structuredInputSources: ["file", "stdin"], cliOwnedFields: ["id", "artifact", "publication_order"], inputMaxBytes: 32768, compacts: true }),
     op("decisions", "append", [], { ownedFields: ["id", "artifact"], inputMode: "structured", inputRoot: "one decision record", inputSources: ["file", "stdin"], structuredInputSources: ["file", "stdin"], cliOwnedFields: ["id", "artifact"], inputMaxBytes: 32768, compacts: true }),
     op("decisions", "update", [f("--id", "id", "string", { required: true }), f("--satisfaction-state", "satisfaction.state", "string", { required: true, validValues: ["open", "provisionally_satisfied", "user_confirmed_satisfied"] }), f("--satisfaction-evidence", "satisfaction.evidence", "string"), f("--confirmed-by", "satisfaction.user_confirmation.confirmed_by", "string"), f("--confirmed-at", "satisfaction.user_confirmation.confirmed_at", "string")], { selectors: ["--id"], ownedFields: ["id", "artifact", "satisfaction"] }),
@@ -42,10 +43,12 @@ const RUNTIME_OPERATIONS = [
     op("plan", "record-evaluation", planEvaluationFields, { selectors: ["--id", "--plan"], ownedFields: ["id", "artifact", "plan", "evaluation"] }),
     op("plan", "archive", [f("--plan", "plan", "string")], { selectors: ["--plan"], ownedFields: ["id", "artifact", "plan", "header.status"], allowForce: true }),
     op("plan", "create", [], { ownedFields: ["id", "artifact", "header.id", "previous_plan_archived", "task_ids"], inputMode: "structured", inputRoot: "complete plan document", inputSources: ["file", "stdin"], structuredInputSources: ["file", "stdin"], cliOwnedFields: ["id", "artifact", "header.id", "previous_plan_archived", "task_ids"], inputMaxBytes: 32768, allowForce: true }),
-    op("health", "append", [], { ownedFields: ["id", "artifact", "appended_at"], inputMode: "structured", inputRoot: "one audit entry", inputSources: ["file", "stdin"], structuredInputSources: ["file", "stdin"], cliOwnedFields: ["id", "artifact", "appended_at"], inputMaxBytes: 32768, compacts: true }),
+    op("health", "append", [], { ownedFields: ["id", "artifact", "appended_at"], inputMode: "structured", inputRoot: "one audit entry", inputSources: ["file", "stdin"], structuredInputSources: ["file", "stdin"], cliOwnedFields: ["id", "artifact", "appended_at"], inputMaxBytes: 32768, compacts: true, recoveryCommand: ["check", "validate", "state", "--format", "json"] }),
     op("objective", "create", [], { ownedFields: ["id", "artifact", "header.id"], inputMode: "structured", inputRoot: "one objective document", inputSources: ["file", "stdin"], structuredInputSources: ["file", "stdin"], cliOwnedFields: ["id", "artifact", "header.id"], inputMaxBytes: 32768 }),
     op("objective", "update", [f("--id", "id", "string", { required: true })], { selectors: ["--id"], ownedFields: ["id", "artifact", "header.id"], inputMode: "structured", inputRoot: "one objective document", inputSources: ["file", "stdin"], structuredInputSources: ["file", "stdin"], cliOwnedFields: ["id", "artifact", "header.id"], inputMaxBytes: 32768 }),
     op("experiments", "publish", [f("--objective", "objective", "string", { required: true }), f("--id", "id", "string")], { selectors: ["--objective", "--id"], ownedFields: ["id", "artifact", "objective", "archive_identity"], inputMode: "structured", inputRoot: "one experiment entry", inputSources: ["file", "stdin"], structuredInputSources: ["file", "stdin"], cliOwnedFields: ["id", "artifact", "objective"], inputMaxBytes: 32768, compacts: true }),
+    op("todo", "activate", [f("--effect-sha256", "effect_sha256", "string"), f("--yes", "confirmed", "boolean")], { ownedFields: ["reconciliation", "public_document", "activation"], compacts: true }),
+    op("todo", "repair", [f("--effect-sha256", "effect_sha256", "string"), f("--yes", "confirmed", "boolean")], { ownedFields: ["reconciliation", "public_document", "activation"], compacts: true }),
     op("todo", "create", [], { ownedFields: ["id", "artifact", "status", "public_order", "lifecycle"], inputMode: "structured", inputRoot: "full typed TODO record", inputSources: ["file", "stdin"], structuredInputSources: ["file", "stdin"], cliOwnedFields: ["id", "artifact", "status", "public_order", "lifecycle"], inputMaxBytes: 32768 }),
     op("todo", "update", [f("--id", "id", "string", { required: true })], { selectors: ["--id"], ownedFields: ["id", "artifact", "status", "public_order", "lifecycle"], inputMode: "structured", inputRoot: "TODO record patch", inputSources: ["file", "stdin"], structuredInputSources: ["file", "stdin"], cliOwnedFields: ["id", "artifact", "status", "public_order", "lifecycle"], inputMaxBytes: 32768 }),
     op("todo", "set-severity", [f("--id", "id", "string", { required: true }), f("--severity", "severity", "string", { required: true, validValues: ["critical", "degraded", "normal", "annoying"] }), f("--reason", "lifecycle.reason", "string", { required: true }), f("--date", "lifecycle.date", "date", { required: true })], { selectors: ["--id"], ownedFields: ["id", "artifact", "severity", "lifecycle"] }),
@@ -56,10 +59,84 @@ const RUNTIME_OPERATIONS = [
     op("docs", "update", [f("--id", "id", "string", { required: true })], { selectors: ["--id"], ownedFields: ["id", "artifact"], inputMode: "structured", inputRoot: "one documentation inventory entry", inputSources: ["file", "stdin"], structuredInputSources: ["file", "stdin"], cliOwnedFields: ["id", "artifact"], inputMaxBytes: 32768 }),
     op("glossary", "publish", [], { ownedFields: ["approval_id", "glossary_entry_id"], inputMode: "structured", inputRoot: "one glossary publication request", inputSources: ["file", "stdin"], structuredInputSources: ["file", "stdin"], inputMaxBytes: 32768 }),
 ];
+const LOCAL_PREFIX = "agentera";
+function developmentCommand(argumentsText) {
+    return `${CANONICAL_DEVELOPMENT_CLI} ${argumentsText}`;
+}
+function projectionTemplate(source) {
+    return {
+        source,
+        runtime: source.split(CANONICAL_DEVELOPMENT_CLI).join(LOCAL_PREFIX),
+    };
+}
+function projection(recovery, ...examples) {
+    return {
+        recovery: projectionTemplate(recovery),
+        examples: examples.map(projectionTemplate),
+        formatValues: ["text", "json"],
+    };
+}
+const RUNTIME_OPERATION_PROJECTIONS = {
+    "progress.append": projection(`Run \`${developmentCommand("state progress explain --verb append --format json")}\` and correct the rejected field; no state was changed.`, developmentCommand("state progress append --input progress.yaml --format json")),
+    "decisions.append": projection(`Run \`${developmentCommand("state decisions explain --verb append --format json")}\` and supply every required field; no state was changed.`, developmentCommand("state decisions append --input decision.yaml --format json")),
+    "decisions.update": projection(`Run ${developmentCommand("state decisions explain --verb update --format json")}, use the returned bare decision ID, and provide a valid satisfaction transition.`, developmentCommand('state decisions update --id qjtrmnpvka --satisfaction-state provisionally_satisfied --satisfaction-evidence "..." --format json')),
+    "decisions.amend": projection("Reread the exact decision, copy its current effective SHA-256, and retry with at least one amendable field; no state was changed.", developmentCommand("state decisions amend --id qjtrmnpvka --base-sha256 HASH --input amendment.yaml --format json")),
+    "plan.append": projection(`Use ${developmentCommand("state plan explain --verb append --format json")}, select an open plan, and supply one complete task record with bare same-plan dependencies.`, developmentCommand("state plan append --plan qjtrmnpvka --input task.yaml --format json")),
+    "plan.update": projection("Reread the plan task by its bare ID, supply an omission-preserving patch through --input, and retry; no state was changed.", developmentCommand("state plan update --id qjtrmnpvka --plan abcdefghij --input task-patch.yaml --format json")),
+    "plan.set-status": projection("Reread the task list, copy its bare task ID, and use one of complete, in_progress, pending, or blocked.", developmentCommand("state plan set-status --id qjtrmnpvka --status complete --format json")),
+    "plan.supersede": projection("Complete and evaluate each replacement task with latest PASS evidence, then retry with the returned bare IDs.", developmentCommand('state plan supersede --id qjtrmnpvka --by zqtrmnpvka --reason "Replacement task" --format json')),
+    "plan.set-plan-status": projection("Keep the plan open or resolve every incomplete task and replacement evaluation before retrying completion.", developmentCommand("state plan set-plan-status --status complete --format json")),
+    "plan.record-evaluation": projection("Use the task's bare ID, a stable attempt ID, and evaluator provenance, then retry without changing published evidence.", developmentCommand('state plan record-evaluation --id qjtrmnpvka --attempt-id audit-1 --verdict pass --provenance "audit report" --format json')),
+    "plan.archive": projection("Complete or preserve the selected plan, then retry archive with no content flags; no state was changed.", developmentCommand("state plan archive --dry-run --format json")),
+    "plan.create": projection(`Run ${developmentCommand("state plan explain --verb create --format json")}, keep task ordinals and dependencies local to this atomic input, remove CLI-owned fields, and correct the first schema or dependency violation.`, developmentCommand("state plan create --input plan.yaml --format json")),
+    "health.append": projection(`Run ${developmentCommand("check validate state --format json")}, preserve audit evidence, and retry with one schema-valid audit entry.`, developmentCommand("state health append --input audit.yaml --format json")),
+    "objective.create": projection("Remove identity fields assigned by the CLI and retry with one schema-valid objective document.", developmentCommand("state objective create --input objective.yaml --format json")),
+    "objective.update": projection("Reread the objective, copy its bare ID to --id, remove CLI-owned fields, and retry.", developmentCommand("state objective update --id qjtrmnpvka --input objective.yaml --format json")),
+    "experiments.publish": projection("Use a bare objective ID, omit numeric legacy selectors, and retry the exact input; divergent immutable identities remain untouched.", developmentCommand("state experiments publish --objective qjtrmnpvka --input experiment.yaml --format json")),
+    "todo.activate": projection("Preview and review every reported activation effect before explicit confirmed apply; use the returned examples without modification.", developmentCommand("state todo activate --dry-run --format json"), developmentCommand("state todo activate --effect-sha256 EFFECT_SHA256 --yes --format json")),
+    "todo.repair": projection("Preview and review every diagnosed repair decision before explicit confirmed apply; ambiguous evidence is rejected without effects.", developmentCommand("state todo repair --dry-run --format json"), developmentCommand("state todo repair --effect-sha256 EFFECT_SHA256 --yes --format json")),
+    "todo.create": projection(`Run ${developmentCommand("state todo explain --verb create --format json")}, remove CLI-owned fields, provide the full typed TODO record, and retry.`, developmentCommand("state todo create --input todo.yaml --format json")),
+    "todo.update": projection("Reread the TODO item, use its bare ID, supply only typed patch fields, and use null or an empty list only for declared clearable fields.", developmentCommand("state todo update --id qjtrmnpvka --input todo-patch.yaml --format json")),
+    "todo.set-severity": projection("Use the bare TODO ID, one immediate-impact severity, a reason, and a YYYY-MM-DD date; no record input is accepted.", developmentCommand('state todo set-severity --id qjtrmnpvka --severity degraded --reason "Impact changed" --date 2026-07-31 --format json')),
+    "todo.supersede": projection("Use the selected bare TODO ID, an existing distinct replacement ID, a reason, and a YYYY-MM-DD date; no record input is accepted.", developmentCommand('state todo supersede --id qjtrmnpvka --replacement zqtrmnpvka --reason "Replaced by narrower work" --date 2026-07-31 --format json')),
+    "todo.resolve": projection("Use the bare TODO ID, a reason, and a YYYY-MM-DD date; no record input is accepted.", developmentCommand('state todo resolve --id qjtrmnpvka --reason "Shipped" --date 2026-07-31 --format json')),
+    "todo.reopen": projection("Use the bare resolved TODO ID, a reason, and a YYYY-MM-DD date; no record input is accepted.", developmentCommand('state todo reopen --id qjtrmnpvka --reason "Scope returned" --date 2026-07-31 --format json')),
+    "docs.create": projection("Remove id and artifact from the input and retry with one schema-valid documentation inventory entry.", developmentCommand("state docs create --input documentation.yaml --format json")),
+    "docs.update": projection("Reread the documentation entry, copy its bare ID to --id, remove CLI-owned fields, and retry.", developmentCommand("state docs update --id qjtrmnpvka --input documentation.yaml --format json")),
+    "glossary.publish": projection(`Run ${developmentCommand("state glossary explain --verb publish --format json")} and correct the bounded request or confirmation.`, developmentCommand("state glossary publish --input glossary-publication.yaml --format json")),
+};
+const operationKeys = RUNTIME_OPERATION_CORES.map(({ artifact, verb }) => `${artifact}.${verb}`);
+const projectionKeys = Object.keys(RUNTIME_OPERATION_PROJECTIONS);
+const missingProjection = operationKeys.find((key) => !(key in RUNTIME_OPERATION_PROJECTIONS));
+const unknownProjection = projectionKeys.find((key) => !operationKeys.includes(key));
+if (missingProjection || unknownProjection) {
+    throw new Error(`invalid runtime operation projection registry: ${missingProjection ? `missing ${missingProjection}` : `unknown ${unknownProjection}`}`);
+}
+const RUNTIME_OPERATIONS = RUNTIME_OPERATION_CORES.map((operation) => ({
+    ...operation,
+    projection: RUNTIME_OPERATION_PROJECTIONS[`${operation.artifact}.${operation.verb}`],
+}));
+function cloneOperation(spec) {
+    return {
+        ...spec,
+        selectors: [...spec.selectors],
+        ownedFields: [...spec.ownedFields],
+        inputSources: [...spec.inputSources],
+        structuredInputSources: [...spec.structuredInputSources],
+        cliOwnedFields: [...spec.cliOwnedFields],
+        ...(spec.recoveryCommand ? { recoveryCommand: [...spec.recoveryCommand] } : {}),
+        fields: spec.fields.map((field) => ({ ...field, ...(field.validValues ? { validValues: [...field.validValues] } : {}) })),
+        projection: {
+            recovery: { ...spec.projection.recovery },
+            examples: spec.projection.examples.map((example) => ({ ...example })),
+            formatValues: [...spec.projection.formatValues],
+        },
+    };
+}
 export function runtimeOperationSpecs() {
-    return RUNTIME_OPERATIONS.map((spec) => ({ ...spec, fields: spec.fields.map((field) => ({ ...field })) }));
+    return RUNTIME_OPERATIONS.map(cloneOperation);
 }
 export function runtimeOperationSpec(artifact, verb) {
-    return RUNTIME_OPERATIONS.find((spec) => spec.artifact === artifact && spec.verb === verb) ?? null;
+    const spec = RUNTIME_OPERATIONS.find((candidate) => candidate.artifact === artifact && candidate.verb === verb);
+    return spec ? cloneOperation(spec) : null;
 }
-//# sourceMappingURL=runtimeOperations.js.map

package/dist/state/write/serialize.js

@@ -1,2 +1 @@
 export { dumpYamlMapping } from "../../core/yaml.js";
-//# sourceMappingURL=serialize.js.map

package/dist/state/write/transaction.js

@@ -50,4 +50,3 @@ export function executeStateWrite(req, _options = {}) {
         publicationContext.close();
     }
 }
-//# sourceMappingURL=transaction.js.map

package/dist/state/write/validate.js

@@ -5,4 +5,3 @@ export function validateArtifactBytes(artifact, content, validator = new Artifac
         return [`${artifact}: schema '${artifact}' is not available`];
     return validator.validateYaml(content, schema, artifact);
 }
-//# sourceMappingURL=validate.js.map

package/dist/upgrade/appContentRefresh.js

@@ -381,4 +381,3 @@ export function applyAppContentRefreshItems(items, ctx) {
         }
     }
 }
-//# sourceMappingURL=appContentRefresh.js.map

package/dist/upgrade/appModel.js

@@ -191,4 +191,3 @@ export function resolveActiveAppModel(value = null, opts = {}) {
         runtimeRoot: roots.runtimeRoot,
     };
 }
-//# sourceMappingURL=appModel.js.map

package/dist/upgrade/atomicWriter.js

@@ -1,2 +1 @@
 export { writeFileAtomic } from "../core/atomicWriter.js";
-//# sourceMappingURL=atomicWriter.js.map

package/dist/upgrade/bundleEvidence.js

@@ -31,4 +31,3 @@ export function hasBundleRootEvidence(root) {
     }
     return readScriptHead(path.join(root, "scripts", "agentera")) !== null;
 }
-//# sourceMappingURL=bundleEvidence.js.map

package/dist/upgrade/channels.js

@@ -225,4 +225,3 @@ export function parseConfigUpdateChannel(text) {
     }
     return parseChannelValue(raw, "config_file");
 }
-//# sourceMappingURL=channels.js.map

package/dist/upgrade/compatibility.js

@@ -234,4 +234,3 @@ export function foreignLayoutHasUnexpectedEntries(root) {
         return false;
     }
 }
-//# sourceMappingURL=compatibility.js.map

package/dist/upgrade/doctor.js

@@ -377,4 +377,3 @@ export function doctorParityJsonEnvelope(status) {
     }
     return out;
 }
-//# sourceMappingURL=doctor.js.map

package/dist/upgrade/doctorClassifier.js

@@ -185,4 +185,3 @@ export function classifyInstallRootStatus(ctx) {
     const classifier = ROOT_CLASSIFIERS[kind] ?? classifyManaged;
     return classifier(ctx);
 }
-//# sourceMappingURL=doctorClassifier.js.map

package/dist/upgrade/installedHooksRetirement.js

@@ -194,4 +194,3 @@ export function installedBundleHasV2HookInvocationText(appHome) {
 export function isV2HookScript(filePath) {
     return isFile(filePath) && filePath.endsWith(".py") && filePath.includes(`${path.sep}hooks${path.sep}`);
 }
-//# sourceMappingURL=installedHooksRetirement.js.map

package/dist/upgrade/legacyAgentCleanup.js

@@ -280,4 +280,3 @@ export function applyLegacyAgentCleanupItems(items, ctx) {
         }
     }
 }
-//# sourceMappingURL=legacyAgentCleanup.js.map

package/dist/upgrade/lifecycleUpgrade.js

@@ -111,4 +111,3 @@ export function runLifecycleUpgrade(args, options = {}) {
         requiredUnmet,
     };
 }
-//# sourceMappingURL=lifecycleUpgrade.js.map

package/dist/upgrade/migrateArtifactsV2ToV3.js

@@ -11,7 +11,7 @@ import { doctorRoots } from "./appModel.js";
 import { AGENTERA_USER_STATE_NAMES, } from "./doctor.js";
 import { appHomeHasUnrecognizedEntriesWithPreflight, handoffCatalogMessage, resolveMigrationUserStatePreflight, } from "../migrate/v2HandoffManifest.js";
 import { applyLegacyAgentCleanupItems, planLegacyAgentCleanupItems, planLegacyCapabilityAgentCleanupItems, } from "./legacyAgentCleanup.js";
-import { applyRuntimeMigrationItems, planRuntimeMigrationItems, resolveNpxHookCommands, rewireRuntimeText, } from "./runtimeMigration.js";
+import { applyRuntimeMigrationItems, planRuntimeMigrationItems, } from "./runtimeMigration.js";
 import { writeFileAtomic } from "./atomicWriter.js";
 import { bindMigrationTree, cloneMigrationItem, removeBoundMigrationTree } from "./migrationPublication.js";
 import { applyInstalledHooksRetirementItems, planInstalledHooksRetirementItems, } from "./installedHooksRetirement.js";
@@ -27,13 +27,6 @@ export const V1_ARTIFACT_PAIRS = [
     [".agentera/DOCS.md", ".agentera/docs.yaml"],
     ["VISION.md", ".agentera/vision.yaml"],
 ];
-/** Default development-channel npm entrypoint for tests and legacy imports. */
-export const NPX_CLI_ENTRYPOINT = "npx -y agentera@next";
-export const NPX_HOOK_VALIDATE = `${NPX_CLI_ENTRYPOINT} hook validate-artifact`;
-export const NPX_HOOK_CURSOR_SESSION_START = `${NPX_CLI_ENTRYPOINT} hook cursor-session-start`;
-export const NPX_HOOK_CURSOR_SESSION_STOP = `${NPX_CLI_ENTRYPOINT} hook session-stop`;
-export const NPX_HOOK_CURSOR_PRE_TOOL = `${NPX_CLI_ENTRYPOINT} hook cursor-pre-tool-use`;
-export { rewireRuntimeText, resolveNpxHookCommands };
 const PLAN_ARCHIVE_FILE = /^PLAN-.+\.ya?ml$/i;
 const PLAN_LIFECYCLE_ACTION = "normalize-plan-lifecycle";
 function isMapping(value) {
@@ -293,8 +286,8 @@ export function delegatePlanLifecycleToEntityCutover(phase) {
     phase.status = updated.status;
     phase.summary = updated.summary;
 }
-export function planRuntimeRewirePhase(ctx, resolvedChannel) {
-    const items = planRuntimeMigrationItems(ctx, resolvedChannel);
+export function planRuntimeRetirementPhase(ctx, _resolvedChannel) {
+    const items = planRuntimeMigrationItems(ctx);
     const blockedPaths = new Set(items
         .filter((item) => item.status === "blocked")
         .flatMap((item) => [item.source, item.target])
@@ -305,9 +298,9 @@ export function planRuntimeRewirePhase(ctx, resolvedChannel) {
         item.status = "blocked";
         item.message = "action required before Agentera can modify this runtime resource";
     }
-    return summarizePhase("runtime", items, items.length === 0 ? "no runtime configs with Python managed app-home references found" : "");
+    return summarizePhase("runtime", items, items.length === 0 ? "no retired native Agentera hooks found" : "");
 }
-export function applyRuntimeRewirePhase(phase, ctx) {
+export function applyRuntimeRetirementPhase(phase, ctx) {
     if (ctx) {
         applyRuntimeMigrationItems(phase.items, ctx);
     }
@@ -535,7 +528,7 @@ export function applyCleanupPhase(phase, ctx) {
 export function dryRunMigration(ctx) {
     return {
         artifacts: planArtifactsPhase(ctx.project),
-        runtime: planRuntimeRewirePhase(ctx),
+        runtime: planRuntimeRetirementPhase(ctx),
         cleanup: planCleanupPhase(ctx),
     };
 }
@@ -549,11 +542,10 @@ export function applyMigrationPhases(ctx, preview, only = ["artifacts", "runtime
         applyArtifactsPhase(result.artifacts, ctx.project, ctx.force);
     }
     if (only.includes("runtime")) {
-        applyRuntimeRewirePhase(result.runtime, ctx);
+        applyRuntimeRetirementPhase(result.runtime, ctx);
     }
     if (only.includes("cleanup")) {
         applyCleanupPhase(result.cleanup, ctx);
     }
     return result;
 }
-//# sourceMappingURL=migrateArtifactsV2ToV3.js.map

package/dist/upgrade/migrationPublication.js

@@ -120,4 +120,3 @@ export function removeBoundMigrationTree(item) {
         removeLifecycleResource({ id: `${item.action}.remove`, destination: entry.destination, kind: entry.kind }, entry.observation);
     }
 }
-//# sourceMappingURL=migrationPublication.js.map

package/dist/upgrade/nextMajorDoctor.js

@@ -153,4 +153,3 @@ export function prependNextMajorDoctorSection(text, sectionLines) {
     }
     return `${sectionLines.join("\n")}\n\n${text}`;
 }
-//# sourceMappingURL=nextMajorDoctor.js.map

package/dist/upgrade/npxPlatformStatus.js

@@ -20,4 +20,3 @@ export function resolveNpxPlatformStatus(opts) {
     const platformStatus = buildDoctorStatus(platformRoot, doctorOpts);
     return { platformRoot, platformStatus };
 }
-//# sourceMappingURL=npxPlatformStatus.js.map

package/dist/upgrade/projectIntegration.js

@@ -4,9 +4,8 @@ import { APP_MIGRATION_NEEDED, APP_MANUAL_REVIEW_NEEDED, APP_OUTDATED, APP_REPAI
 import { resolveNpxPlatformStatus } from "./npxPlatformStatus.js";
 import { classifyInstall, crossMajorBoundaryApplies } from "./compatibility.js";
 import { resolveInvokedUpdateChannel } from "./channels.js";
-import fs from "node:fs";
-import { detectV1ArtifactPairs, planRuntimeRewirePhase, } from "./migrateArtifactsV2ToV3.js";
-import { projectHasProjectLevelRuntimeHooks, textUsesPythonManagedEntrypoint, } from "./runtimeMigration.js";
+import { detectV1ArtifactPairs, planRuntimeRetirementPhase, } from "./migrateArtifactsV2ToV3.js";
+import { projectHasProjectLevelRuntimeHooks, } from "./runtimeMigration.js";
 import { isStableSuccessorAnnounced } from "./nextMajorDoctor.js";
 import { buildUpgradeCommands } from "./upgradeCommands.js";
 import { classifyIntegrationScenario, integrationScenarioMessage, integrationExit, integrationPhase, } from "./projectIntegrationDecision.js";
@@ -20,17 +19,6 @@ function isPendingRuntimeMigrationItem(item) {
     if (item.status !== "pending" || item.action === "configure") {
         return false;
     }
-    if (item.action === "rewire-runtime") {
-        if (!item.source) {
-            return false;
-        }
-        try {
-            return textUsesPythonManagedEntrypoint(fs.readFileSync(item.source, "utf8"));
-        }
-        catch {
-            return false;
-        }
-    }
     return true;
 }
 function isGlobalStaleRuntimeItem(item, ctx) {
@@ -38,13 +26,13 @@ function isGlobalStaleRuntimeItem(item, ctx) {
     if (!item.source?.startsWith(homeRoot)) {
         return false;
     }
-    if (item.action === "rewire-runtime" || item.action === "retire-hooks") {
+    if (item.action === "retire-hooks") {
         return true;
     }
     return false;
 }
 export function pendingRuntimeMigrationItems(ctx, resolvedChannel) {
-    const phase = planRuntimeRewirePhase(ctx, resolvedChannel);
+    const phase = planRuntimeRetirementPhase(ctx, resolvedChannel);
     const projectRoot = resolvePath(ctx.project);
     const hasProjectHooks = projectHasProjectLevelRuntimeHooks(ctx.project);
     return phase.items.filter((item) => {
@@ -242,4 +230,3 @@ export function projectIntegrationAttention(summary) {
     const previewText = summary.dry_run_command ? ` Preview ${preview}.` : "";
     return `${prefix}: ${summary.message}${previewText}`;
 }
-//# sourceMappingURL=projectIntegration.js.map

package/dist/upgrade/projectIntegrationDecision.js

@@ -48,4 +48,3 @@ export function integrationExit(hasPendingWork, appBlocked) {
         return { code: 1, meaning: "preview_required" };
     return { code: 1, meaning: "manual_review_required" };
 }
-//# sourceMappingURL=projectIntegrationDecision.js.map

package/dist/upgrade/retiredResourceDiagnostics.js

@@ -0,0 +1,117 @@
+import fs from "node:fs";
+import path from "node:path";
+import { loadNativeResourceCleanupContract, retiredResourceDiagnosticIds, } from "../runtime/nativeResourceCleanup.js";
+function templateRoot(template, roots) {
+    const match = /^\{(home|project|install_root)\}\//.exec(template);
+    if (!match)
+        throw new Error(`unsafe retired-resource diagnostic path template: ${template}`);
+    return roots[match[1]];
+}
+function expandTemplate(template, roots, name) {
+    const root = templateRoot(template, roots);
+    const expanded = template
+        .replace("{home}", roots.home)
+        .replace("{project}", roots.project)
+        .replace("{install_root}", roots.install_root)
+        .replace("{name}", name ?? "");
+    if (expanded.includes("{") || expanded.includes("..")) {
+        throw new Error(`unsafe retired-resource diagnostic path template: ${template}`);
+    }
+    const resolved = path.resolve(expanded);
+    const relative = path.relative(root, resolved);
+    if (relative === "" || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+        throw new Error(`retired-resource diagnostic path escapes its root: ${template}`);
+    }
+    return resolved;
+}
+function fileContains(pathname, marker, maximumFileBytes) {
+    let stat;
+    try {
+        stat = fs.lstatSync(pathname);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        return "uninspectable";
+    }
+    if (!stat.isFile() || stat.size > maximumFileBytes)
+        return "uninspectable";
+    const fd = fs.openSync(pathname, "r");
+    try {
+        const content = Buffer.alloc(stat.size);
+        fs.readSync(fd, content, 0, content.length, 0);
+        return content.toString("utf8").includes(marker) ? "path_present" : null;
+    }
+    catch {
+        return "uninspectable";
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function observeDestination(pathname, definition, maximumFileBytes) {
+    if (definition.contains) {
+        const observation = fileContains(pathname, definition.contains, maximumFileBytes);
+        return observation ? { path: pathname, observation } : null;
+    }
+    try {
+        fs.lstatSync(pathname);
+        return { path: pathname, observation: "path_present" };
+    }
+    catch (error) {
+        return error.code === "ENOENT"
+            ? null
+            : { path: pathname, observation: "uninspectable" };
+    }
+}
+function namesFor(definition) {
+    return definition.id.includes("{name}") || definition.destinations.some((item) => item.includes("{name}"))
+        ? definition.names
+        : [""];
+}
+export function diagnoseRetiredResources(opts) {
+    const contract = opts.contract ?? loadNativeResourceCleanupContract();
+    if (opts.resourceId && !retiredResourceDiagnosticIds(contract).includes(opts.resourceId)) {
+        throw new Error(`unknown retired Agentera resource ID: ${opts.resourceId}`);
+    }
+    const roots = {
+        home: path.resolve(opts.home),
+        project: path.resolve(opts.project),
+        install_root: path.resolve(opts.installRoot),
+    };
+    const observed = new Map();
+    for (const definition of contract.diagnosticResources) {
+        for (const name of namesFor(definition)) {
+            const id = definition.id.replace("{name}", name);
+            if (opts.resourceId && id !== opts.resourceId)
+                continue;
+            for (const destination of definition.destinations) {
+                const pathname = expandTemplate(destination, roots, name || null);
+                const observation = observeDestination(pathname, definition, contract.diagnosticMaximumFileBytes);
+                if (!observation)
+                    continue;
+                const current = observed.get(id) ?? [];
+                current.push(observation);
+                observed.set(id, current);
+            }
+        }
+    }
+    const entries = [...observed.entries()].sort(([left], [right]) => left.localeCompare(right));
+    const retained = entries.slice(0, contract.diagnosticMaximumResources).map(([id, observations]) => ({
+        id,
+        status: "action_required",
+        evidence: {
+            paths: [...new Set(observations.map((observation) => observation.path))].sort(),
+            observation: observations.some((observation) => observation.observation === "uninspectable")
+                ? "uninspectable"
+                : "path_present",
+        },
+    }));
+    return {
+        schemaVersion: "agentera.retiredResourceDiagnosis.v1",
+        status: retained.length > 0 || entries.length > contract.diagnosticMaximumResources ? "action_required" : "clean",
+        selectedResourceId: opts.resourceId ?? null,
+        resources: retained,
+        omittedResourceCount: Math.max(0, entries.length - retained.length),
+    };
+}