@jstn-sdk/ma 0.1.12 → 0.14.0

package/plugins/meta-architect/obsidian/manifest.json

@@ -0,0 +1,9 @@
+{
+  "id": "meta-architect",
+  "name": "Meta-Architect",
+  "version": "0.14.0",
+  "minAppVersion": "1.5.0",
+  "description": "Connects active Obsidian notes, selections, graph metadata, canvases, attachments, and request queues to Meta-Architect vault context.",
+  "author": "JustineDevs",
+  "isDesktopOnly": false
+}

package/plugins/meta-architect/obsidian/styles.css

@@ -0,0 +1,7 @@
+.ma-status {
+  color: var(--text-muted);
+}
+
+.ma-context-modal pre {
+  white-space: pre-wrap;
+}

package/plugins/meta-architect/skills/arch/SKILL.md

@@ -11,9 +11,11 @@ Use this skill inside Codex to turn a product idea into a concrete architecture
 
 Produce:
 - problem framing
+- `decision`, `status`, `evidence`, `blockers`, `next_allowed_triggers`
 - user and workload assumptions
 - system architecture and subsystem boundaries
 - stack recommendation with tradeoffs
+- rejected alternatives with rationale
 - data model and storage choices
 - auth, security, and operational concerns
 - phased delivery plan

package/plugins/meta-architect/skills/build/SKILL.md

@@ -14,11 +14,14 @@ Produce:
 - blockers that still prevent implementation
 - the narrowest viable build slice
 - branch or worktree suggestions when relevant
+- bounded execution state when the build lane is already in progress
 - test and verification expectations
+- repair path when the bounded slice needs another pass
 - the exact next implementation step
 
 ## Rules
 
 - Do not claim readiness if architecture, evidence, logic, security, or DX/UX gaps remain unresolved.
 - Keep the recommended build slice small, testable, and reversible.
+- Treat `$build` as the sole owner of `.ma/plans/build.md` and `build_status`.
 - If the user wants code immediately and the path is clear, end with a concrete implementation plan rather than more review prose.

package/plugins/meta-architect/skills/flow/SKILL.md

@@ -10,7 +10,9 @@ Use this skill inside Codex to pressure-test how the system behaves, not just ho
 ## Output
 
 Produce:
+- `decision`, `status`, `evidence`, `blockers`, `next_allowed_triggers`
 - key actors and system states
+- state map and failure flows
 - main flows and failure flows
 - invariants and state transitions
 - race conditions, dead ends, and consistency risks

package/plugins/meta-architect/skills/sage/SKILL.md

@@ -11,8 +11,10 @@ Use this skill inside Codex to verify or challenge stack choices with real sourc
 
 Produce:
 - candidate tools, libraries, or services
+- `decision`, `status`, `evidence`, `blockers`, `next_allowed_triggers`
 - why each option fits or fails the architecture
 - source-backed evidence from official docs, upstream repos, or approved GitMCP sources
+- evidence grade and exact upstream mapping
 - recommendation with tradeoffs
 - unresolved gaps or missing evidence
 - exact next trigger, usually `$flow`

package/plugins/meta-architect/skills/sage/references/source-selection.md

@@ -23,6 +23,14 @@ Use this reference pack inside `$sage` when the repo needs evidence-backed selec
 - Claimed capability verified from a primary source
 - Maturity caveats called out when evidence is weak
 
+## Evidence grades
+
+- `VERIFIED`: exact upstream mapping plus primary-source confirmation
+- `PARTIAL`: candidate is mapped, but live proof or maturity proof is incomplete
+- `MISSING`: no trustworthy exact upstream mapping yet
+
+Always expose the evidence grade and the exact upstream mapping in user-facing `$sage` output.
+
 ## Native posture
 
 Meta-Architect ships curated guidance and playbooks. It does not ship a raw mirror of external catalogs. External sources remain evidence inputs, not user-facing skill identities.

package/plugins/meta-architect/skills/vet/SKILL.md

@@ -10,11 +10,13 @@ Use this skill inside Codex to review security posture before the build lane. `$
 ## Output
 
 Produce:
+- `decision`, `status`, `evidence`, `blockers`, `next_allowed_triggers`
 - trust boundaries
 - authn/authz expectations
 - sensitive data paths
 - abuse cases and likely failure modes
 - concrete mitigations
+- accepted risks
 - release blockers vs acceptable risks
 - exact next trigger, usually `$vibe`
 

package/plugins/meta-architect/skills/vet/references/security-playbooks.md

@@ -18,6 +18,13 @@ Use this reference pack inside `$vet` for repeatable trust-boundary reviews that
 - Distinguish blockers from accepted risk.
 - Route remediation back to the owning lane rather than creating a parallel security workflow.
 
+## Adversarial hardening
+
+- For higher-risk changes, run a bounded adversarial hardening pass before final approval.
+- Keep the hardening work inside the private scratchpad/runtime layer.
+- Return structured findings, not direct gate mutations.
+- If the hardening pass cannot resolve or clearly classify the risk, keep `$vet` in a non-terminal state instead of over-approving.
+
 ## Product boundary
 
 This pack deepens `$vet`; it does not create a new security skill family. Security patterns are packaged as Meta-Architect guidance, not as mirrored external catalogs or branded upstream surfaces.

package/plugins/meta-architect/skills/vibe/SKILL.md

@@ -10,8 +10,10 @@ Use this skill inside Codex to review whether the system will feel coherent for
 ## Output
 
 Produce:
+- `decision`, `status`, `evidence`, `blockers`, `next_allowed_triggers`
 - developer workflow risks
 - user workflow risks
+- operator friction and user friction
 - complexity hotspots
 - onboarding or operability friction
 - simplifications that improve clarity

package/schemas/autonomous-task-queue.schema.json

@@ -0,0 +1,56 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://meta-architect.dev/schemas/autonomous-task-queue.schema.json",
+  "title": "Meta-Architect Autonomous Task Queue",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schemaVersion", "record_type", "tasks"],
+  "properties": {
+    "schemaVersion": { "const": "0.1.0" },
+    "record_type": { "const": "autonomous_task_queue" },
+    "tasks": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": [
+          "id",
+          "goal",
+          "priority",
+          "dependencies",
+          "labels",
+          "status",
+          "attempts",
+          "maxAttempts",
+          "contract",
+          "createdAt",
+          "updatedAt"
+        ],
+        "properties": {
+          "id": { "type": "string", "minLength": 1 },
+          "goal": { "type": "string", "minLength": 1 },
+          "priority": { "enum": ["low", "normal", "high", "critical"] },
+          "dependencies": { "type": "array", "items": { "type": "string" } },
+          "labels": { "type": "array", "items": { "type": "string" } },
+          "deadline": { "type": ["string", "null"], "format": "date-time" },
+          "status": {
+            "enum": ["queued", "running", "completed", "failed", "blocked", "cancelled"]
+          },
+          "attempts": { "type": "integer", "minimum": 0 },
+          "maxAttempts": { "type": "integer", "minimum": 1 },
+          "vendor": { "type": ["string", "null"] },
+          "contract": { "$ref": "task-contract.schema.json" },
+          "createdAt": { "type": "string", "format": "date-time" },
+          "updatedAt": { "type": "string", "format": "date-time" },
+          "startedAt": { "type": ["string", "null"], "format": "date-time" },
+          "completedAt": { "type": ["string", "null"], "format": "date-time" },
+          "error": { "type": ["string", "null"] },
+          "blocker": { "type": ["string", "null"] },
+          "evidence": { "type": "array", "items": {} },
+          "selectedCapabilities": { "type": "array", "items": { "type": "object" } },
+          "invocation": { "type": ["string", "null"] }
+        }
+      }
+    }
+  }
+}

package/schemas/handoff-packet.schema.json

@@ -0,0 +1,36 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://meta-architect.dev/schemas/handoff-packet.schema.json",
+  "title": "Meta-Architect Handoff Packet",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "schemaVersion",
+    "record_type",
+    "goal",
+    "current_state",
+    "context_used",
+    "decisions",
+    "blockers",
+    "risks",
+    "changed_files",
+    "verification",
+    "next_action",
+    "status"
+  ],
+  "properties": {
+    "schemaVersion": { "const": "0.1.0" },
+    "record_type": { "const": "handoff_packet" },
+    "goal": { "type": "string", "minLength": 1 },
+    "current_state": { "type": "string", "minLength": 1 },
+    "context_used": { "type": "array", "items": { "type": "string" } },
+    "decisions": { "type": "array", "items": { "type": "string" } },
+    "blockers": { "type": "array", "items": { "type": "string" } },
+    "risks": { "type": "array", "items": { "type": "string" } },
+    "changed_files": { "type": "array", "items": { "type": "string" } },
+    "verification": { "type": "array", "items": { "type": "string" } },
+    "next_action": { "type": "string", "minLength": 1 },
+    "status": { "enum": ["active", "blocked", "verified"] },
+    "created_at": { "type": "string", "format": "date-time" }
+  }
+}

package/schemas/setup-receipt.schema.json

@@ -0,0 +1,28 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "required": ["schemaVersion", "record_type", "generatedAt", "managedBy", "artifacts"],
+  "properties": {
+    "schemaVersion": { "const": "0.1.0" },
+    "record_type": { "const": "setup_receipt" },
+    "generatedAt": { "type": "string", "format": "date-time" },
+    "managedBy": { "const": "@jstn-sdk/ma" },
+    "artifacts": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["path", "kind", "status", "created"],
+        "properties": {
+          "path": { "type": "string", "minLength": 1 },
+          "kind": { "enum": ["file", "directory"] },
+          "status": {
+            "enum": ["created", "existing", "refreshed", "skipped", "warning", "failed"]
+          },
+          "created": { "type": "boolean" }
+        },
+        "additionalProperties": true
+      }
+    }
+  },
+  "additionalProperties": true
+}

package/schemas/skill-frontmatter.schema.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://meta-architect.jstn.site/schemas/skill-frontmatter.schema.json",
+  "$comment": "Schema version: 1.0.0",
+  "title": "Meta-Architect skill frontmatter",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["name", "description"],
+  "properties": {
+    "name": {
+      "type": "string",
+      "pattern": "^[a-z0-9-]+$",
+      "minLength": 1
+    },
+    "description": {
+      "type": "string",
+      "minLength": 10
+    }
+  }
+}

package/schemas/support-bundle.schema.json

@@ -0,0 +1,37 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://meta-architect.dev/schemas/support-bundle.schema.json",
+  "type": "object",
+  "required": ["schemaVersion", "bundleVersion", "assets", "compatibility"],
+  "properties": {
+    "schemaVersion": { "const": "1.0.0" },
+    "bundleVersion": { "type": "string", "pattern": "^[0-9]+\\.[0-9]+\\.[0-9]+$" },
+    "compatibility": {
+      "type": "object",
+      "required": ["node", "managedBy"],
+      "properties": {
+        "node": { "type": "string", "minLength": 1 },
+        "managedBy": { "const": "@jstn-sdk/ma" }
+      },
+      "additionalProperties": false
+    },
+    "assets": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "required": ["name", "class", "source", "destination", "type", "required"],
+        "properties": {
+          "name": { "type": "string", "pattern": "^[a-z0-9-]+$" },
+          "class": { "enum": ["runtime", "guidance", "plugin", "documentation"] },
+          "source": { "type": "string", "pattern": "^(?!/)(?!.*(?:^|/)\\.\\.(?:/|$)).+" },
+          "destination": { "type": "string", "pattern": "^(?!/)(?!.*(?:^|/)\\.\\.(?:/|$)).+" },
+          "type": { "enum": ["file", "directory"] },
+          "required": { "type": "boolean" }
+        },
+        "additionalProperties": false
+      }
+    }
+  },
+  "additionalProperties": false
+}

package/schemas/task-contract.schema.json

@@ -0,0 +1,31 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://meta-architect.dev/schemas/task-contract.schema.json",
+  "title": "Meta-Architect Task Contract",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "schemaVersion",
+    "record_type",
+    "goal",
+    "context_used",
+    "assumptions",
+    "constraints",
+    "risk",
+    "verification",
+    "stop_condition"
+  ],
+  "properties": {
+    "schemaVersion": { "const": "0.1.0" },
+    "record_type": { "const": "task_contract" },
+    "goal": { "type": "string", "minLength": 1 },
+    "context_used": { "type": "array", "items": { "type": "string" } },
+    "assumptions": { "type": "array", "items": { "type": "string" } },
+    "constraints": { "type": "array", "items": { "type": "string" } },
+    "risk": { "enum": ["low", "medium", "high"] },
+    "verification": { "type": "array", "items": { "type": "string" } },
+    "stop_condition": { "type": "string", "minLength": 1 },
+    "persist": { "type": "boolean" },
+    "created_at": { "type": "string", "format": "date-time" }
+  }
+}

package/scripts/active-autonomy-hook.mjs

@@ -0,0 +1,226 @@
+#!/usr/bin/env node
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import {
+  createDefaultActiveAutonomyCore,
+  detectPassivePermissionHandoff,
+} from "../src/runtime/active-autonomy-core.js";
+import { resolveHookProfile } from "../src/runtime/hook-profiles.js";
+import { maskSensitiveText } from "../src/runtime/redaction-gateway.js";
+
+const DEFAULT_RESPONSE =
+  "AUTO-CONTINUE: continue the current safe branch, execute the next reversible step, then verify before reporting.";
+
+async function readStdinJson() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+
+  const raw = Buffer.concat(chunks).toString("utf8").trim();
+  if (!raw) {
+    return {};
+  }
+
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    return {
+      type: "invalid-hook-payload",
+      raw,
+      parseError: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+function extractAssistantText(payload) {
+  const candidates = [
+    payload.last_assistant_message,
+    payload["last-assistant-message"],
+    payload.message,
+    payload.text,
+    payload.output,
+  ];
+
+  for (const candidate of candidates) {
+    if (typeof candidate === "string" && candidate.trim()) {
+      return candidate;
+    }
+  }
+
+  if (Array.isArray(payload.messages)) {
+    const assistant = [...payload.messages]
+      .reverse()
+      .find((message) => message?.role === "assistant" && typeof message.content === "string");
+    return assistant?.content ?? "";
+  }
+
+  return "";
+}
+
+function extractUserText(payload) {
+  const candidates = [
+    payload.last_user_message,
+    payload["last-user-message"],
+    payload.user_message,
+    payload.prompt,
+  ];
+
+  for (const candidate of candidates) {
+    if (typeof candidate === "string" && candidate.trim()) return candidate;
+  }
+
+  if (Array.isArray(payload.messages)) {
+    const user = [...payload.messages]
+      .reverse()
+      .find((message) => message?.role === "user" && typeof message.content === "string");
+    return user?.content ?? "";
+  }
+
+  return "";
+}
+
+function redactAuditPreview(value) {
+  if (typeof value !== "string" || !value) return { value: value ?? "", redactions: [] };
+  const redacted = maskSensitiveText(value.slice(0, 200));
+  return {
+    value: redacted.sanitizedText,
+    redactions: redacted.replacements.map(({ placeholder, placeholderBase }) => ({
+      placeholder,
+      placeholderBase,
+    })),
+  };
+}
+
+async function appendAudit(cwd, entry) {
+  const auditDir = path.join(cwd, ".ma", "hooks");
+  await fs.mkdir(auditDir, { recursive: true });
+  const assistantPreview = redactAuditPreview(entry.assistantPreview);
+  const userPreview = redactAuditPreview(entry.userPreview);
+  const safeEntry = {
+    ...entry,
+    ...(entry.assistantPreview !== undefined ? { assistantPreview: assistantPreview.value } : {}),
+    ...(entry.userPreview !== undefined ? { userPreview: userPreview.value } : {}),
+    previewRedactions: {
+      assistant: assistantPreview.redactions,
+      user: userPreview.redactions,
+    },
+  };
+  await fs.appendFile(
+    path.join(auditDir, "audit.log"),
+    `${JSON.stringify({ timestamp: new Date().toISOString(), ...safeEntry })}\n`,
+    "utf8",
+  );
+}
+
+function classifyFinding(file) {
+  const value = String(file ?? "").toLowerCase();
+  if (/(node_modules|site-packages|vendor)/.test(value)) return "dependency";
+  if (/(dist|build|\.next|coverage|cache)/.test(value)) return "generated";
+  if (/(compat|legacy|history)/.test(value)) return "compatibility";
+  return "source";
+}
+
+async function writeBlockingReceipt(cwd, receipt) {
+  const receiptDir = path.join(cwd, ".ma", "hooks", "receipts");
+  await fs.mkdir(receiptDir, { recursive: true });
+  const receiptPath = path.join(receiptDir, `active-autonomy-${Date.now()}.json`);
+  await fs.writeFile(receiptPath, `${JSON.stringify(receipt, null, 2)}\n`, "utf8");
+  return path.relative(cwd, receiptPath);
+}
+
+const payload = await readStdinJson();
+const profile = resolveHookProfile(payload.profile);
+const cwd = path.resolve(
+  payload.project_root ||
+    payload.cwd ||
+    payload.working_directory ||
+    process.env.MA_ROOT ||
+    process.cwd(),
+);
+const broadScan =
+  profile.scanScope === "broad" ||
+  payload.broad_scan === true ||
+  process.env.MA_HOOK_BROAD_SCAN === "1";
+const ignoredArtifactClasses = [
+  "node_modules",
+  ".next",
+  "dist",
+  "build",
+  "coverage",
+  "cache",
+  "venv",
+  ".venv",
+  "site-packages",
+  "vendored bundles",
+];
+const assistantText = extractAssistantText(payload);
+const userText = extractUserText(payload);
+const blocked =
+  profile.block && detectPassivePermissionHandoff(assistantText, createDefaultActiveAutonomyCore());
+
+const result = blocked
+  ? {
+      decision: "block",
+      reason: DEFAULT_RESPONSE,
+      stopReason: "active_autonomy_passive_handoff",
+      systemMessage:
+        "Meta-Architect Active Autonomy blocked passive permission-handoff wording on an AUTO-CONTINUE branch.",
+    }
+  : {
+      decision: "approve",
+      reason: "active_autonomy_no_passive_handoff_detected",
+    };
+
+const matchedFiles = Array.isArray(payload.files) ? payload.files : [];
+const receiptPath = blocked
+  ? await writeBlockingReceipt(cwd, {
+      schemaVersion: "0.1.0",
+      record_type: "hook_receipt",
+      hook: "active-autonomy",
+      ruleId: "active_autonomy_passive_handoff",
+      scanRoot: cwd,
+      include: broadScan ? ["all"] : ["active-project"],
+      exclude: broadScan ? [] : ignoredArtifactClasses,
+      matchedFiles: matchedFiles.map((file) => ({
+        path: String(file.path ?? file),
+        line: Number.isInteger(file.line) ? file.line : null,
+        classification: classifyFinding(file.path ?? file),
+      })),
+      classification: matchedFiles.some((file) => classifyFinding(file.path ?? file) === "source")
+        ? "source"
+        : "false_positive_candidate",
+      blocked: true,
+      reason: result.reason,
+      recommendedAction: "Rewrite the response to continue the safe branch and verify it.",
+      suppressionPolicy: "No suppression without an explicit rationale.",
+      createdAt: new Date().toISOString(),
+      profile: profile.id,
+    })
+  : null;
+
+if (!profile.readOnly)
+  await appendAudit(cwd, {
+    hook: "active-autonomy",
+    scanRoot: cwd,
+    scope: broadScan ? "broad-opt-in" : "active-project",
+    ignoredArtifactClasses: broadScan ? [] : ignoredArtifactClasses,
+    event: payload.type || payload.event || "unknown",
+    decision: result.decision,
+    stopReason: result.stopReason,
+    assistantPreview: assistantText,
+    userPreview: userText,
+  });
+
+process.stdout.write(
+  `${JSON.stringify({
+    ...result,
+    scanRoot: cwd,
+    scope: broadScan ? "broad-opt-in" : "active-project",
+    ignoredArtifactClasses: broadScan ? [] : ignoredArtifactClasses,
+    profile: profile.id,
+    readOnly: profile.readOnly,
+    ...(receiptPath ? { receiptPath } : {}),
+  })}\n`,
+);

package/scripts/build-linux-packages.mjs

@@ -2,9 +2,9 @@
 
 import { spawnSync } from "node:child_process";
 import fsp from "node:fs/promises";
-import os from "node:os";
 import path from "node:path";
 import process from "node:process";
+import { createTestNamespace } from "../src/test-fixtures.js";
 import {
   getDebArtifactPath,
   getLinuxPackageManifestPath,
@@ -87,6 +87,10 @@ async function createCommonRoot(root, packArtifactPath) {
   run("tar", ["-xzf", packArtifactPath, "-C", libRoot, "--strip-components=1", "package"], {
     cwd: repoRoot,
   });
+  const agentCompatSource = path.join(repoRoot, "node_modules", "@jstn-sdk", "agents");
+  const agentCompatTarget = path.join(libRoot, "node_modules", "@jstn-sdk", "agents");
+  await fsp.access(agentCompatSource);
+  await copyDir(agentCompatSource, agentCompatTarget);
 
   const wrapper = `#!/bin/sh
 PREFIX="\${META_ARCHITECT_PREFIX:-}"
@@ -267,6 +271,7 @@ async function main() {
 
   await fsp.mkdir(distRoot, { recursive: true });
   const packArtifactPath = getPackArtifactPath(distRoot, packageName, version);
+  const workRoot = createTestNamespace("meta-architect-linux-packages");
   await fsp.rm(packArtifactPath, { force: true });
   run(
     "npm",
@@ -275,14 +280,13 @@ async function main() {
       ".",
       "--ignore-scripts",
       "--cache",
-      path.join(distRoot, ".npm-cache"),
+      path.join(workRoot, "npm-cache"),
       "--pack-destination",
       distRoot,
     ],
     { cwd: repoRoot },
   );
 
-  const workRoot = await fsp.mkdtemp(path.join(os.tmpdir(), "meta-architect-linux-packages-"));
   const commonRoot = path.join(workRoot, "root");
   await createCommonRoot(commonRoot, packArtifactPath);
 

package/scripts/cleanup-test-fixtures.sh

@@ -0,0 +1,55 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+REQUESTED_TMP_DIR="${MA_TEST_ROOT:-/tmp/ma-tests}"
+MAX_SIZE_BYTES=$((2 * 1024 * 1024 * 1024))
+
+case "$REQUESTED_TMP_DIR" in
+  /tmp/ma-tests|/tmp/ma-tests/*) ;;
+  *) echo "Refusing to clean unexpected path: $REQUESTED_TMP_DIR" >&2; exit 2 ;;
+esac
+
+TMP_DIR=$(node -e 'const path = require("node:path"); process.stdout.write(path.resolve(process.argv[1]));' "$REQUESTED_TMP_DIR")
+case "$TMP_DIR" in
+  /tmp/ma-tests|/tmp/ma-tests/*) ;;
+  *) echo "Refusing to clean resolved path: $TMP_DIR" >&2; exit 2 ;;
+esac
+
+if [ ! -d "$TMP_DIR" ]; then
+  echo "Test fixture root does not exist: $TMP_DIR"
+  exit 0
+fi
+
+find "$TMP_DIR" -type f \( -name '*.tar.zst' -o -name '*.tar.gz' \) -mtime +7 -delete
+find "$TMP_DIR" -type f -name '*.log' -mtime +3 -delete
+namespace_is_active() {
+  local namespace="$1"
+  local pid
+  if [ ! -f "$namespace/.active" ]; then return 1; fi
+  pid=$(cat "$namespace/.active" 2>/dev/null || true)
+  [[ "$pid" =~ ^[0-9]+$ ]] && kill -0 "$pid" 2>/dev/null
+}
+
+prune_namespaces_older_than() {
+  local age_minutes="$1"
+  local namespace
+  shopt -s nullglob
+  for namespace in "$TMP_DIR"/*; do
+    [ -d "$namespace" ] || continue
+    [ "$(basename "$namespace")" = retained ] && continue
+    namespace_is_active "$namespace" && continue
+    find "$namespace" -maxdepth 0 -type d -mmin +"$age_minutes" -exec rm -rf -- {} +
+  done
+}
+
+# Retained archives have their own seven-day policy and are not namespaces.
+prune_namespaces_older_than 1440
+
+CURRENT_KIB=$(du -sk "$TMP_DIR" 2>/dev/null | cut -f1 || echo 0)
+CURRENT_BYTES=$((CURRENT_KIB * 1024))
+echo "Current $TMP_DIR usage: $CURRENT_BYTES bytes"
+
+if [ "$CURRENT_BYTES" -gt "$MAX_SIZE_BYTES" ]; then
+  echo "::warning::$TMP_DIR exceeded 2GB; removing expired namespaces"
+  prune_namespaces_older_than 60
+fi