mindforge-cc 11.9.8 → 11.9.9

package/.agent/mindforge/health.md

@@ -14,10 +14,13 @@ Run all seven health-engine categories from `.mindforge/intelligence/health-engi
 - informational signals
 
 ## Sovereign Intelligence Checks (v6.2.0-alpha)
-- **PQAS Verification**: Check `bin/governance/quantum-crypto.js` presence
-- **Homing Verification**: Check `bin/autonomous/intent-harvester.js` presence
-- **Self-Healer Verification**: Check `bin/autonomous/mesh-self-healer.js` presence
-- **Policy Check**: Verify `bin/governance/policy-engine.js` is Sovereign-configured
+These are file-presence checks only, not functional verification — PQAS is simulated/inactive by
+default (`pqas_enabled=false` in `.mindforge/config.json`; see MINDFORGE.md `[PQAS_ENFORCED]`).
+- **PQAS file present**: Check `bin/governance/quantum-crypto.js` exists (the module itself has no
+  CLI entrypoint and performs no framework-signature verification)
+- **Homing file present**: Check `bin/autonomous/intent-harvester.js` exists
+- **Self-Healer file present**: Check `bin/autonomous/mesh-self-healer.js` exists
+- **Policy check**: Read `bin/governance/policy-engine.js` for illegal bypass additions
 
 ## Flags
 - `--repair`: apply safe auto-repair only

package/.agent/mindforge/help.md

@@ -18,11 +18,15 @@ If `.planning/PROJECT.md` is missing, treat the project as "Not initialised".
 | /mindforge:init-project      | ...                                          |
 | ...                          | ...                                          |
 
-## Sovereign Intelligence (v6.2.0-alpha)
-MindForge now operates with **Sovereign Intelligence** enabled by default:
-- **PQAS**: Post-Quantum Agentic Security is active. High-risk operations require biometric/executive bypass.
-- **Proactive Homing**: The swarm now proactively harvests intent and self-heals reasoning drifts.
-- **Integrity**: Every `security-scan` now verifies framework signatures using lattice-based cryptography.
+## Sovereign Intelligence (v6.2.0-alpha) — status
+- **PQAS**: Post-Quantum Agentic Security is simulated/inactive by default (`pqas_enabled=false`,
+  gated behind `experimental.pqc_demo` in `.mindforge/config.json`; see MINDFORGE.md
+  `[PQAS_ENFORCED]`). There is no biometric/executive bypass gate. Tier-3 trust uses real Ed25519
+  signing, not PQAS.
+- **Proactive Homing**: advisory framing around `bin/autonomous/intent-harvester.js` — not a
+  verified drift-detection guarantee.
+- **Integrity**: `/mindforge:security-scan` does not verify framework signatures via lattice-based
+  cryptography — see that command's own Step 1.5 for what it actually checks.
 
 4. After the table, print:
    "Current project: [read PROJECT.md first line, or 'Not initialised']"

package/.agent/mindforge/install-skill.md

@@ -13,16 +13,18 @@ Steps:
    node bin/mindforge-cli.js validate-skill ./SKILL.md
    ```
 5. Run injection guard check (handled by validator).
-6. Install to tier directory:
+6. Install to tier directory (the literal `install` action token is required —
+   `bin/skill-registry.js` deliberately has no default action, to stop an
+   unvalidated write from happening by accident):
    ```bash
-   node bin/mindforge-cli.js install-skill [skill-name] --tier [1|2|3]
+   node bin/mindforge-cli.js install-skill install [skill-name] --tier [1|2|3]
    ```
-7. Register in MANIFEST.md:
+7. Register in MANIFEST.md (same deliberate requirement — literal `register` token):
    ```bash
-   node bin/mindforge-cli.js register-skill [skill-name] [version] [tier]
+   node bin/mindforge-cli.js register-skill register [skill-name] [version] [tier]
    ```
-8. Write AUDIT entry:
+8. Write AUDIT entry (same — literal `audit` token):
    ```bash
-   node bin/mindforge-cli.js audit-skill [skill-name] [version] [tier]
+   node bin/mindforge-cli.js audit-skill audit [skill-name] [version] [tier]
    ```
 9. Confirm: "Run /mindforge:skills validate to verify installation"

package/.agent/mindforge/marketplace.md

@@ -13,6 +13,12 @@ marketplace — a curated layer on top of the npm registry.
 The marketplace is the shortcut: instead of learning from documentation yourself,
 install skills that the community has already created, validated, and battle-tested.
 
+**Status: no packages are published today.** Checked live against the npm registry —
+zero `mindforge-skill-*` packages exist. Every result, install count, and quality score
+shown in the examples below (`prisma-advanced`, `847 installs this week`, etc.) is
+illustrative sample output showing the intended format once skills are published, not
+a result you can reproduce right now.
+
 ## Sub-commands
 
 ### search [query]

package/.agent/mindforge/security-scan.md

@@ -20,10 +20,15 @@ This command runs entirely in security mode. Do not switch personas.
 
 ## Step 1.5 — Sovereign Integrity Check (v6.2.0-alpha)
 
-Before scanning user code, verify the integrity of the MindForge Sovereign Engine:
-1.  **Quantum Signature Verification**: Run `node bin/governance/quantum-crypto.js --verify .mindforge/engine/`.
-2.  **Policy Integrity**: Ensure `bin/governance/policy-engine.js` has not been tampered with (check for illegal bypass additions).
-3.  **Result**: If integrity check fails, mark the entire scan as **FAILED (CRITICAL)** and alert the user of a potential framework compromise.
+`bin/governance/quantum-crypto.js` has no CLI entrypoint — running it with `--verify` (or any
+argument) silently ignores the argument and exits 0. It cannot detect tampering and must not be
+treated as a gate. Do the one integrity check that is real instead:
+1.  **Policy Integrity**: Read `bin/governance/policy-engine.js` and check for illegal bypass
+    additions (e.g. an unconditional `return true` short-circuit, a hardcoded allowlist added
+    outside `.mindforge/config.json`).
+2.  **Result**: If policy tampering is found, mark the entire scan as **FAILED (CRITICAL)** and
+    alert the user of a potential framework compromise. Do not fail the scan based on the
+    quantum-crypto step — it performs no real verification.
 
 ```bash
 # Default: staged + unstaged changes

package/.agent/mindforge/skills-index.md

@@ -94,7 +94,7 @@ Lists all skills available in this MindForge installation. Skills in the **Engin
 `llm-wiki` · `polymarket` · `parallel-cli`
 
 ### Security
-`godmode` · `1password-skill`
+`1password-skill`
 
 ### Creative
 `hyperframes` · `article-illustrator` · `comic-creator` · `video-orchestrator`

package/.agent/mindforge/status.md

@@ -88,13 +88,14 @@ Open Issues
 ```
 Sovereign Intelligence (v6.2.0-alpha)
 ───────────────────────────────────────────────────────
-  🛡️  PQAS Security : [ACTIVE | PASSIVE] (Dilithium-5)
+  🛡️  PQAS Security : SIMULATED / INACTIVE (pqas_enabled=false — see MINDFORGE.md [PQAS_ENFORCED])
   🎯  Proactive Homing: [ENABLED | DISABLED]
   🧠  Drift Recovery : [N] remediation events
-  🧬  Biometric Gate : [LOCKED | BYPASSED]
 ```
-- PQAS Status: Check if `bin/governance/quantum-crypto.js` exists and if `PolicyEngine.js` has `highRiskBypass` enabled.
-- Proactive Homing: Check if `bin/autonomous/intent-harvester.js` is active in `AutoRunner.js`.
+- PQAS Status: report from MINDFORGE.md `[PQAS_ENFORCED]` and `.mindforge/config.json`
+  `pqas_enabled` — never report ACTIVE unless that config key is literally `true`. There is no
+  biometric gate; do not report one.
+- Proactive Homing: Check if `bin/autonomous/intent-harvester.js` is active in `bin/autonomous/auto-runner.js`.
 
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ```

package/.claude/commands/mindforge/health.md

@@ -14,10 +14,13 @@ Run all seven health-engine categories from `.mindforge/intelligence/health-engi
 - informational signals
 
 ## Sovereign Intelligence Checks (v6.2.0-alpha)
-- **PQAS Verification**: Check `bin/governance/quantum-crypto.js` presence
-- **Homing Verification**: Check `bin/autonomous/intent-harvester.js` presence
-- **Self-Healer Verification**: Check `bin/autonomous/mesh-self-healer.js` presence
-- **Policy Check**: Verify `bin/governance/policy-engine.js` is Sovereign-configured
+These are file-presence checks only, not functional verification — PQAS is simulated/inactive by
+default (`pqas_enabled=false` in `.mindforge/config.json`; see MINDFORGE.md `[PQAS_ENFORCED]`).
+- **PQAS file present**: Check `bin/governance/quantum-crypto.js` exists (the module itself has no
+  CLI entrypoint and performs no framework-signature verification)
+- **Homing file present**: Check `bin/autonomous/intent-harvester.js` exists
+- **Self-Healer file present**: Check `bin/autonomous/mesh-self-healer.js` exists
+- **Policy check**: Read `bin/governance/policy-engine.js` for illegal bypass additions
 
 ## Flags
 - `--repair`: apply safe auto-repair only

package/.claude/commands/mindforge/help.md

@@ -18,11 +18,15 @@ If `.planning/PROJECT.md` is missing, treat the project as "Not initialised".
 | /mindforge:init-project      | ...                                          |
 | ...                          | ...                                          |
 
-## Sovereign Intelligence (v6.2.0-alpha)
-MindForge now operates with **Sovereign Intelligence** enabled by default:
-- **PQAS**: Post-Quantum Agentic Security is active. High-risk operations require biometric/executive bypass.
-- **Proactive Homing**: The swarm now proactively harvests intent and self-heals reasoning drifts.
-- **Integrity**: Every `security-scan` now verifies framework signatures using lattice-based cryptography.
+## Sovereign Intelligence (v6.2.0-alpha) — status
+- **PQAS**: Post-Quantum Agentic Security is simulated/inactive by default (`pqas_enabled=false`,
+  gated behind `experimental.pqc_demo` in `.mindforge/config.json`; see MINDFORGE.md
+  `[PQAS_ENFORCED]`). There is no biometric/executive bypass gate. Tier-3 trust uses real Ed25519
+  signing, not PQAS.
+- **Proactive Homing**: advisory framing around `bin/autonomous/intent-harvester.js` — not a
+  verified drift-detection guarantee.
+- **Integrity**: `/mindforge:security-scan` does not verify framework signatures via lattice-based
+  cryptography — see that command's own Step 1.5 for what it actually checks.
 
 4. After the table, print:
    "Current project: [read PROJECT.md first line, or 'Not initialised']"

package/.claude/commands/mindforge/install-skill.md

@@ -13,16 +13,18 @@ Steps:
    node bin/mindforge-cli.js validate-skill ./SKILL.md
    ```
 5. Run injection guard check (handled by validator).
-6. Install to tier directory:
+6. Install to tier directory (the literal `install` action token is required —
+   `bin/skill-registry.js` deliberately has no default action, to stop an
+   unvalidated write from happening by accident):
    ```bash
-   node bin/mindforge-cli.js install-skill [skill-name] --tier [1|2|3]
+   node bin/mindforge-cli.js install-skill install [skill-name] --tier [1|2|3]
    ```
-7. Register in MANIFEST.md:
+7. Register in MANIFEST.md (same deliberate requirement — literal `register` token):
    ```bash
-   node bin/mindforge-cli.js register-skill [skill-name] [version] [tier]
+   node bin/mindforge-cli.js register-skill register [skill-name] [version] [tier]
    ```
-8. Write AUDIT entry:
+8. Write AUDIT entry (same — literal `audit` token):
    ```bash
-   node bin/mindforge-cli.js audit-skill [skill-name] [version] [tier]
+   node bin/mindforge-cli.js audit-skill audit [skill-name] [version] [tier]
    ```
 9. Confirm: "Run /mindforge:skills validate to verify installation"

package/.claude/commands/mindforge/marketplace.md

@@ -13,6 +13,12 @@ marketplace — a curated layer on top of the npm registry.
 The marketplace is the shortcut: instead of learning from documentation yourself,
 install skills that the community has already created, validated, and battle-tested.
 
+**Status: no packages are published today.** Checked live against the npm registry —
+zero `mindforge-skill-*` packages exist. Every result, install count, and quality score
+shown in the examples below (`prisma-advanced`, `847 installs this week`, etc.) is
+illustrative sample output showing the intended format once skills are published, not
+a result you can reproduce right now.
+
 ## Sub-commands
 
 ### search [query]

package/.claude/commands/mindforge/security-scan.md

@@ -20,10 +20,15 @@ This command runs entirely in security mode. Do not switch personas.
 
 ## Step 1.5 — Sovereign Integrity Check (v6.2.0-alpha)
 
-Before scanning user code, verify the integrity of the MindForge Sovereign Engine:
-1.  **Quantum Signature Verification**: Run `node bin/governance/quantum-crypto.js --verify .mindforge/engine/`.
-2.  **Policy Integrity**: Ensure `bin/governance/policy-engine.js` has not been tampered with (check for illegal bypass additions).
-3.  **Result**: If integrity check fails, mark the entire scan as **FAILED (CRITICAL)** and alert the user of a potential framework compromise.
+`bin/governance/quantum-crypto.js` has no CLI entrypoint — running it with `--verify` (or any
+argument) silently ignores the argument and exits 0. It cannot detect tampering and must not be
+treated as a gate. Do the one integrity check that is real instead:
+1.  **Policy Integrity**: Read `bin/governance/policy-engine.js` and check for illegal bypass
+    additions (e.g. an unconditional `return true` short-circuit, a hardcoded allowlist added
+    outside `.mindforge/config.json`).
+2.  **Result**: If policy tampering is found, mark the entire scan as **FAILED (CRITICAL)** and
+    alert the user of a potential framework compromise. Do not fail the scan based on the
+    quantum-crypto step — it performs no real verification.
 
 ```bash
 # Default: staged + unstaged changes

package/.claude/commands/mindforge/skills-index.md

@@ -94,7 +94,7 @@ Lists all skills available in this MindForge installation. Skills in the **Engin
 `llm-wiki` · `polymarket` · `parallel-cli`
 
 ### Security
-`godmode` · `1password-skill`
+`1password-skill`
 
 ### Creative
 `hyperframes` · `article-illustrator` · `comic-creator` · `video-orchestrator`

package/.claude/commands/mindforge/status.md

@@ -88,13 +88,14 @@ Open Issues
 ```
 Sovereign Intelligence (v6.2.0-alpha)
 ───────────────────────────────────────────────────────
-  🛡️  PQAS Security : [ACTIVE | PASSIVE] (Dilithium-5)
+  🛡️  PQAS Security : SIMULATED / INACTIVE (pqas_enabled=false — see MINDFORGE.md [PQAS_ENFORCED])
   🎯  Proactive Homing: [ENABLED | DISABLED]
   🧠  Drift Recovery : [N] remediation events
-  🧬  Biometric Gate : [LOCKED | BYPASSED]
 ```
-- PQAS Status: Check if `bin/governance/quantum-crypto.js` exists and if `PolicyEngine.js` has `highRiskBypass` enabled.
-- Proactive Homing: Check if `bin/autonomous/intent-harvester.js` is active in `AutoRunner.js`.
+- PQAS Status: report from MINDFORGE.md `[PQAS_ENFORCED]` and `.mindforge/config.json`
+  `pqas_enabled` — never report ACTIVE unless that config key is literally `true`. There is no
+  biometric gate; do not report one.
+- Proactive Homing: Check if `bin/autonomous/intent-harvester.js` is active in `bin/autonomous/auto-runner.js`.
 
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ```

package/.mindforge/config.json

@@ -1,5 +1,5 @@
 {
-  "version": "11.9.8",
+  "version": "11.9.9",
   "environment": "development",
   "governance": {
     "drift_threshold": 0.75,

package/.mindforge/dynamic-workflows/scripts/feature-planner.js

@@ -77,6 +77,9 @@ const brief = await agent(
   `Create a feature brief for: "${feature}". Clarify the core problem, target users, measurable success criteria, and explicit out-of-scope items.`,
   { schema: BRIEF_SCHEMA, label: 'brief' }
 );
+if (!brief) {
+  return { feature, error: 'brief-agent-null' };
+}
 
 phase('PRD');
 const briefText = `Feature: ${brief.featureName}\nProblem: ${brief.problem}\nUsers: ${brief.targetUsers}\nSuccess: ${brief.successCriteria.join(', ')}`;
@@ -84,6 +87,9 @@ const prd = await agent(
   `Write a product requirements document for this feature:\n${briefText}\n\nInclude functional requirements (must/should/could), non-functional requirements, and acceptance criteria.`,
   { schema: PRD_SCHEMA, label: 'prd' }
 );
+if (!prd) {
+  return { feature, brief, error: 'prd-agent-null' };
+}
 
 phase('Architecture');
 const reqSummary = prd.requirements.slice(0, 8).map(r => `${r.id} [${r.priority}]: ${r.description}`).join('\n');
@@ -91,6 +97,9 @@ const arch = await agent(
   `Design the technical architecture for this feature:\nBrief: ${briefText}\nRequirements:\n${reqSummary}\n\nIdentify the implementation approach, components, data flow, files to create/modify, and key risks.`,
   { schema: ARCH_SCHEMA, label: 'architecture' }
 );
+if (!arch) {
+  return { feature, brief, prd, error: 'arch-agent-null' };
+}
 
 phase('Stories');
 const archSummary = `Approach: ${arch.approach}\nNew files: ${arch.newFiles.join(', ')}\nModified: ${arch.modifiedFiles.join(', ')}`;
@@ -98,5 +107,8 @@ const stories = await agent(
   `Break this feature into user stories:\nBrief: ${briefText}\nArchitecture: ${archSummary}\n\nWrite stories in "As a [user], I want [goal], so that [benefit]" format with acceptance criteria and t-shirt size estimates (XS/S/M/L/XL).`,
   { schema: STORIES_SCHEMA, label: 'stories' }
 );
+if (!stories) {
+  return { feature, brief, prd, architecture: arch, error: 'stories-agent-null' };
+}
 
 return { feature, brief, prd, architecture: arch, stories: stories.stories };

package/.mindforge/dynamic-workflows/scripts/incident-response.js

@@ -65,6 +65,9 @@ const characterization = await agent(
   `Characterize this production incident: "${incident}"\n\nDetermine severity (P0=total outage, P1=major degradation, P2=partial impact, P3=minor), list affected systems, symptoms, and your initial hypothesis about the root cause.`,
   { schema: CHARACTERIZE_SCHEMA, label: 'characterize' }
 );
+if (!characterization) {
+  return { incident, error: 'characterization-agent-null' };
+}
 log(`[${characterization.severity}] ${characterization.incidentTitle} — ${characterization.symptoms.length} symptoms identified`);
 
 phase('Investigate');
@@ -87,6 +90,9 @@ const mitigation = await agent(
   `Based on these investigation findings, identify IMMEDIATE mitigation actions:\n${investigationSummary}\n\nPrioritize actions that restore service quickly. Include rollback steps and estimate recovery time.`,
   { schema: MITIGATE_SCHEMA, label: 'mitigate' }
 );
+if (!mitigation) {
+  return { incident, characterization, investigations: investigations.filter(Boolean), error: 'mitigation-agent-null' };
+}
 
 phase('RCA');
 const allContext = `Incident: ${characterization.incidentTitle}\nInvestigations:\n${investigationSummary}\nMitigation: ${mitigation.immediateActions.map(a => a.action).join(', ')}`;

package/.mindforge/dynamic-workflows/scripts/onboard-codebase.js

@@ -67,6 +67,9 @@ const map = await agent(
   `Map the structure of this codebase: "${repo}"\n\nIdentify: primary language, frameworks, entry points (main files, index, CLI), test frameworks, and the purpose of each top-level directory. Be specific — list actual file paths.`,
   { schema: MAP_SCHEMA, label: 'map' }
 );
+if (!map) {
+  return { repo, error: 'map-agent-null' };
+}
 log(`${map.primaryLanguage} codebase, ${map.frameworks.join('+')} — ${map.keyDirectories.length} key directories`);
 
 phase('Domain');
@@ -75,6 +78,9 @@ const domain = await agent(
   `Identify the business domains and core abstractions in: "${repo}"\n${mapSummary}\n\nWhat problem does this software solve? What are the main domain concepts? What are the key abstractions (models, services, controllers, etc.)?`,
   { schema: DOMAIN_SCHEMA, label: 'domain' }
 );
+if (!domain) {
+  return { repo, map, error: 'domain-agent-null' };
+}
 log(`${domain.domains.length} domains: ${domain.domains.map(d => d.name).join(', ')}`);
 
 phase('Architecture');
@@ -83,6 +89,9 @@ const arch = await agent(
   `Map the technical architecture of: "${repo}"\n${domainSummary}\n\nWhat architecture style (MVC, layered, event-driven, microservices)? What are the layers? How does data flow? What key patterns and gotchas should a new developer know?`,
   { schema: ARCH_SCHEMA, label: 'architecture' }
 );
+if (!arch) {
+  return { repo, map, domain, error: 'arch-agent-null' };
+}
 
 phase('Tour');
 const archSummary = `Style: ${arch.architectureStyle}\nLayers: ${arch.layers.map(l => l.name).join(' → ')}\nPatterns: ${arch.keyPatterns.join(', ')}`;

package/.mindforge/dynamic-workflows/scripts/perf-optimize.js

@@ -84,6 +84,9 @@ const profile = await agent(
   `Identify the slowest code paths and performance bottleneck hypothesis for: "${target}"\n\nWhat are the likely slow endpoints/functions? What profiling commands should be run? What is your initial bottleneck hypothesis?`,
   { schema: PROFILE_SCHEMA, label: 'profile' }
 );
+if (!profile) {
+  return { target, error: 'profile-agent-null' };
+}
 log(`${profile.slowestPaths.length} slow paths identified, hypothesis: ${profile.bottleneckHypothesis.slice(0, 80)}`);
 
 phase('Identify');
@@ -108,6 +111,9 @@ const fixPlan = await agent(
   `Prioritize this performance fix backlog by impact-to-effort ratio:\n${issueList}\n\nRank by: high impact + low effort first. List quick wins (can implement in <1 hour) separately. Include implementation guidance for each.`,
   { schema: FIX_PLAN_SCHEMA, label: 'plan' }
 );
+if (!fixPlan) {
+  return { target, profile, bottlenecks: bottlenecks.filter(Boolean), error: 'fixPlan-agent-null' };
+}
 
 phase('Benchmark');
 const topFixes = fixPlan.prioritized.slice(0, 5).map(f => `${f.rank}. ${f.fix} (expected: ${f.expectedImprovement})`).join('\n');

package/.mindforge/dynamic-workflows/scripts/refactor-plan.js

@@ -101,6 +101,9 @@ const prioritized = await agent(
   `Prioritize this refactoring backlog by risk. Items with narrow blast radius + good test coverage = tackle first (low risk). Wide blast radius + no coverage = tackle last or skip.\n\nDebts:\n${debtList}`,
   { schema: PRIORITY_SCHEMA, label: 'prioritize' }
 );
+if (!prioritized) {
+  return { target, debtItems: allDebts.length, error: 'prioritized-agent-null' };
+}
 
 phase('Sequence');
 const topItems = prioritized.prioritized.slice(0, 10).map(p => `${p.rank}. [${p.risk}] ${p.description}: ${p.rationale}`).join('\n');

package/.mindforge/dynamic-workflows/scripts/release-prep.js

@@ -64,6 +64,9 @@ const readiness = await agent(
   `Check release readiness for: "${context}"\n\nVerify: are there uncommitted changes? Any failing tests? Any security vulnerabilities in dependencies? Any open critical bugs that should block release? List any blockers and warnings.`,
   { schema: READINESS_SCHEMA, label: 'check' }
 );
+if (!readiness) {
+  return { context, error: 'readiness-agent-null' };
+}
 if (!readiness.ready && readiness.blockers.length > 0) {
   log(`BLOCKED: ${readiness.blockers.join(', ')}`);
 }
@@ -74,6 +77,9 @@ const changelog = await agent(
   `Generate a changelog for this release of: "${context}"\n\nAnalyze recent commits (look for conventional commit format: feat/fix/chore/refactor/docs/test/perf/ci). Separate into: breaking changes, new features, bug fixes, chores. Write a highlights summary (2-3 sentences).`,
   { schema: CHANGELOG_SCHEMA, label: 'changelog' }
 );
+if (!changelog) {
+  return { context, readiness, error: 'changelog-agent-null' };
+}
 log(`Changelog: ${changelog.breaking.length} breaking, ${changelog.features.length} features, ${changelog.fixes.length} fixes`);
 
 phase('Bump');
@@ -82,6 +88,9 @@ const version = await agent(
   `Determine the next semantic version for: "${context}"\nChanges: ${changelogSummary}\nHighlights: ${changelog.highlights}\n\nUse semver rules: breaking change = major bump, new features = minor bump, fixes only = patch bump. List all files that need version updated.`,
   { schema: VERSION_SCHEMA, label: 'bump' }
 );
+if (!version) {
+  return { context, readiness, changelog, error: 'version-agent-null' };
+}
 log(`Version: ${version.current} → ${version.next} (${version.bumpType})`);
 
 phase('PR');

package/.mindforge/dynamic-workflows/scripts/tdd-sprint.js

@@ -65,6 +65,9 @@ const spec = await agent(
   `Write a precise behavioral specification for: "${requirement}"\n\nUse Given-When-Then format. Be explicit about inputs, outputs, and edge cases. List what is OUT of scope to keep this focused.`,
   { schema: SPEC_SCHEMA, label: 'spec' }
 );
+if (!spec) {
+  return { requirement, error: 'spec-agent-null' };
+}
 log(`Spec: ${spec.behaviorName} | ${spec.acceptanceCriteria.length} acceptance criteria, ${spec.edgeCases.length} edge cases`);
 
 phase('Red');
@@ -73,6 +76,9 @@ const test = await agent(
   `Write a FAILING test for this behavior specification:\n${specText}\n\nWrite the minimal test that will fail because the implementation doesn't exist yet. Explain WHY it fails. Use the project's test framework (detect from file extensions or state Jest/Vitest/Node assert).`,
   { schema: TEST_SCHEMA, label: 'red' }
 );
+if (!test) {
+  return { requirement, spec, error: 'test-agent-null' };
+}
 log(`[RED] Test: "${test.testDescription}" — fails because: ${test.whyItFails}`);
 
 phase('Green');
@@ -81,6 +87,9 @@ const impl = await agent(
   `Write the MINIMUM implementation to make this test pass:\n${testContext}\n\nWrite ONLY what is needed to make the test go green. No extra features, no future-proofing. Explain why this is the minimal solution.`,
   { schema: IMPL_SCHEMA, label: 'green' }
 );
+if (!impl) {
+  return { requirement, spec, test, error: 'impl-agent-null' };
+}
 log(`[GREEN] Minimal implementation: ${impl.minimalityRationale}`);
 
 phase('Refactor');
@@ -89,6 +98,9 @@ const refactored = await agent(
   `Refactor this passing implementation for clarity and maintainability, keeping all tests green:\n${greenContext}\n\nList specific improvements made (naming, structure, extraction, simplification). The tests MUST still pass after refactoring.`,
   { schema: REFACTOR_SCHEMA, label: 'refactor' }
 );
+if (!refactored) {
+  return { requirement, spec, test, implementation: impl, error: 'refactored-agent-null' };
+}
 log(`[REFACTOR] ${refactored.improvements.length} improvements, tests still pass: ${refactored.testsStillPass}`);
 
 return {

package/.mindforge/dynamic-workflows/scripts/verification-loop.js

@@ -96,10 +96,16 @@ for (let round = 1; round <= maxRounds; round++) {
     : `Task: ${task}\n${metric ? `Metric the scorer will grade against: ${metric}\n` : 'State the metric you are optimizing for, then '}Produce a first complete attempt at the artifact.`;
 
   const revision = await agent(revisePrompt, { label: `implement:r${round}`, phase: 'Round', schema: REVISE_SCHEMA });
+  if (!revision) {
+    return { task, metric: metric || '(scorer-inferred)', finalArtifact: currentArtifact, scoreHistory: scoreHistory.map((s, i) => ({ round: i + 1, score: s.score, topFixes: s.topFixes })), error: 'revision-agent-null' };
+  }
   currentArtifact = revision.artifact;
 
   const scorePrompt = `Score this artifact against the task's metric. Be strict and consistent with how you'd score any round of this same task — same rubric every time, do not grade on a curve relative to the previous round.\n\nTask: ${task}\n${metric ? `Metric: ${metric}\n` : ''}\nArtifact:\n${currentArtifact}`;
   const scored = await agent(scorePrompt, { label: `score:r${round}`, phase: 'Round', schema: SCORE_SCHEMA });
+  if (!scored) {
+    return { task, metric: metric || '(scorer-inferred)', finalArtifact: currentArtifact, scoreHistory: scoreHistory.map((s, i) => ({ round: i + 1, score: s.score, topFixes: s.topFixes })), error: 'scored-agent-null' };
+  }
 
   scoreHistory.push(scored);
   log(`Round ${round}: score ${scored.score}/100`);

package/.mindforge/org/skills/MANIFEST.md

@@ -148,6 +148,38 @@ This file tracks all active, validated, and legacy skills within the MindForge e
 | dns-architecture | .mindforge/skills/dns-architecture/SKILL.md | stable |
 | cdn-optimization | .mindforge/skills/cdn-optimization/SKILL.md | stable |
 | database-sharding-advanced | .mindforge/skills/database-sharding-advanced/SKILL.md | stable |
+| agent-architecture-audit | .mindforge/skills/agent-architecture-audit/SKILL.md | stable |
+| arxiv | .mindforge/skills/arxiv/SKILL.md | stable |
+| blogwatcher | .mindforge/skills/blogwatcher/SKILL.md | stable |
+| code-wiki | .mindforge/skills/code-wiki/SKILL.md | stable |
+| codebase-inspection | .mindforge/skills/codebase-inspection/SKILL.md | stable |
+| concept-diagrams | .mindforge/skills/concept-diagrams/SKILL.md | stable |
+| creative-ideation | .mindforge/skills/creative-ideation/SKILL.md | stable |
+| domain-intel | .mindforge/skills/domain-intel/SKILL.md | stable |
+| duckduckgo-search | .mindforge/skills/duckduckgo-search/SKILL.md | stable |
+| github-code-review | .mindforge/skills/github-code-review/SKILL.md | stable |
+| github-issues | .mindforge/skills/github-issues/SKILL.md | stable |
+| github-pr-workflow | .mindforge/skills/github-pr-workflow/SKILL.md | stable |
+| jupyter-live-kernel | .mindforge/skills/jupyter-live-kernel/SKILL.md | stable |
+| kanban-orchestrator | .mindforge/skills/kanban-orchestrator/SKILL.md | stable |
+| kanban-worker | .mindforge/skills/kanban-worker/SKILL.md | stable |
+| meme-generation | .mindforge/skills/meme-generation/SKILL.md | stable |
+| obsidian | .mindforge/skills/obsidian/SKILL.md | stable |
+| orch-pipeline | .mindforge/skills/orch-pipeline/SKILL.md | stable |
+| osint-investigation | .mindforge/skills/osint-investigation/SKILL.md | stable |
+| oss-forensics | .mindforge/skills/oss-forensics/SKILL.md | stable |
+| pixel-art | .mindforge/skills/pixel-art/SKILL.md | stable |
+| plan | .mindforge/skills/plan/SKILL.md | stable |
+| requesting-code-review | .mindforge/skills/requesting-code-review/SKILL.md | stable |
+| research-paper-writing | .mindforge/skills/research-paper-writing/SKILL.md | stable |
+| scrapling | .mindforge/skills/scrapling/SKILL.md | stable |
+| sherlock | .mindforge/skills/sherlock/SKILL.md | stable |
+| simplify-code | .mindforge/skills/simplify-code/SKILL.md | stable |
+| spike | .mindforge/skills/spike/SKILL.md | stable |
+| subagent-driven-development | .mindforge/skills/subagent-driven-development/SKILL.md | stable |
+| systematic-debugging | .mindforge/skills/systematic-debugging/SKILL.md | stable |
+| test-driven-development | .mindforge/skills/test-driven-development/SKILL.md | stable |
+| web-pentest | .mindforge/skills/web-pentest/SKILL.md | stable |
 
 ## Multi-Agent Skills
 

package/.mindforge/personas/mf-executor.md

@@ -1,7 +1,7 @@
 ---
 name: mf-executor
 description: Implementation specialist focused on high-fidelity execution of provided plans and code completion.
-tools: Read, Write, Bash, multi_replace_file_content
+tools: Read, Write, Edit, Bash
 color: orange
 ---
 

package/.mindforge/personas/mf-memory.md

@@ -1,7 +1,7 @@
 ---
 name: mf-memory
 description: Long-term memory management and knowledge graph synchronization for persistent context.
-tools: Read, Write, commit_memory (Skill-based)
+tools: Read, Write, Grep, Glob
 color: cyan
 ---
 

package/.mindforge/personas/mf-tool.md

@@ -1,7 +1,7 @@
 ---
 name: mf-tool
 description: Safe interaction layer for external systems, infrastructure, and privileged tool operations.
-tools: Bash, Git, Database, API, task_boundary
+tools: Read, Write, Bash, WebFetch
 color: yellow
 ---