aienvmp 0.1.29 → 0.1.31

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.1.31
+
+- Added `aienvmp status` as a compact human and AI entrypoint.
+- Summarized clear/review state, next command, counts, top action, and enforcement advice in one output.
+- Kept `context --json` as the richer preflight while making first checks simpler.
+
+## 0.1.30
+
+- Added shared enforcement advice for AI and CI surfaces.
+- Exposed advisory-by-default behavior, suggested strict scopes, and scoped CI commands in context and plan outputs.
+- Moved strict scope logic into a reusable enforcement module while keeping existing `doctor --strict` behavior compatible.
+
 ## 0.1.29
 
 - Added lightweight remediation priority scoring for vulnerable packages.

package/README.md

@@ -16,6 +16,7 @@ Core loop: scan once, link runtime/dependency/security context, give AI a shared
 
 ```bash
 npx aienvmp sync
+npx aienvmp status
 npx aienvmp context
 npx aienvmp plan
 npx aienvmp handoff
@@ -79,6 +80,7 @@ The dashboard shows which strict scopes are CI-ready before you enforce them.
 
 ```bash
 aienvmp sync              # update env map, light SBOM, ledger, dashboard
+aienvmp status            # one compact clear/review decision
 aienvmp context           # AI preflight brief
 aienvmp context --json    # AI decision contract + actions + compact step summary
 aienvmp plan              # read-only AI action plan using the same decision contract
@@ -97,6 +99,7 @@ aienvmp doctor --strict security  # fail only scoped warnings
 - read-only planning, no automatic fixes
 - one advisory engine, optional enforcement with `doctor --ci`
 - scoped enforcement with `doctor --strict security|policy|coordination|all`
+- context and plan expose suggested strict scopes for CI
 - non-blocking unless strict mode is explicitly requested
 - security checks are opt-in and read-only
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aienvmp",
-  "version": "0.1.29",
+  "version": "0.1.31",
   "description": "AI-first environment maps and lightweight runtime SBOMs for shared development machines.",
   "type": "module",
   "bin": {

package/src/cli.js

@@ -12,6 +12,7 @@ import { syncWorkspace } from "./commands/sync.js";
 import { snippetWorkspace } from "./commands/snippet.js";
 import { handoffWorkspace } from "./commands/handoff.js";
 import { planWorkspace } from "./commands/plan.js";
+import { statusWorkspace } from "./commands/status.js";
 import { readFileSync } from "node:fs";
 
 const commands = new Map([
@@ -28,7 +29,8 @@ const commands = new Map([
   ["sync", syncWorkspace],
   ["snippet", snippetWorkspace],
   ["handoff", handoffWorkspace],
-  ["plan", planWorkspace]
+  ["plan", planWorkspace],
+  ["status", statusWorkspace]
 ]);
 
 const version = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
@@ -78,11 +80,13 @@ function printUsage() {
 Usage:
   aienvmp sync [--dir .] [--json] [--quiet] [--deep] [--security]
   aienvmp context [--dir .] [--json]
+  aienvmp status [--dir .] [--json]
   aienvmp handoff [--dir .] [--json] [--record --actor agent:id]
   aienvmp plan [--dir .] [--json] [--write]
 
 Common:
   aienvmp sync      update AIENV.md, manifest, ledger, intents, and dashboard
+  aienvmp status    print one simple environment decision
   aienvmp context   print the AI preflight brief
   aienvmp handoff   print the next-agent handoff summary
   aienvmp plan      print a read-only AI environment action plan

package/src/commands/context.js

@@ -7,6 +7,7 @@ import { loadPolicy, policyWarnings } from "../policy.js";
 import { recommendedActions } from "../actions.js";
 import { buildPlan, compactStepSummary } from "./plan.js";
 import { aiDecision } from "../decision.js";
+import { enforcementAdvice } from "../enforcement.js";
 
 export async function contextWorkspace(args) {
   const dir = workspaceDir(args);
@@ -23,6 +24,7 @@ export async function contextWorkspace(args) {
     console.log(JSON.stringify({
       status: warnings.length ? "review-required" : "clear",
       decision,
+      enforcement: enforcementAdvice(warnings),
       recommendedActions: actions,
       stepSummary,
       trust: manifest.trust || {},

package/src/commands/dash.js

@@ -8,7 +8,7 @@ import { dashboardPath, intentsPath, manifestPath, planJsonPath, planMdPath, tim
 import { renderDashboard } from "../render.js";
 import { loadPolicy, policyWarnings } from "../policy.js";
 import { recommendedActions } from "../actions.js";
-import { strictResult } from "./doctor.js";
+import { strictResult } from "../enforcement.js";
 
 export async function dashWorkspace(args) {
   const dir = workspaceDir(args);

package/src/commands/doctor.js

@@ -4,6 +4,9 @@ import { openIntents, readJsonl, readTimeline } from "../timeline.js";
 import { intentsPath, manifestPath, timelinePath, workspaceDir } from "../paths.js";
 import { loadPolicy, policyWarnings } from "../policy.js";
 import { recommendedActions } from "../actions.js";
+import { enforcementAdvice, strictResult } from "../enforcement.js";
+
+export { strictResult } from "../enforcement.js";
 
 export async function doctorWorkspace(args) {
   const dir = workspaceDir(args);
@@ -23,6 +26,7 @@ export async function doctorWorkspace(args) {
       openIntentCount: intents.length,
       warnings,
       recommendedActions: actions,
+      enforcement: enforcementAdvice(warnings),
       strict
     }, null, 2));
     if (strict.fail) {
@@ -46,34 +50,3 @@ export async function doctorWorkspace(args) {
     process.exitCode = 1;
   }
 }
-
-export function strictResult(warnings = [], args = {}) {
-  const scope = normalizeStrictScope(args.strict || (args.ci ? "all" : ""));
-  const matchedWarnings = scope ? warnings.filter((warning) => warningMatchesScope(warning, scope)) : [];
-  return {
-    enabled: Boolean(scope),
-    scope: scope || "off",
-    fail: matchedWarnings.length > 0,
-    matchedWarningCodes: matchedWarnings.map((warning) => warning.code),
-    availableScopes: ["security", "policy", "coordination", "all"]
-  };
-}
-
-function normalizeStrictScope(value) {
-  if (value === true) return "all";
-  const scope = String(value || "").trim().toLowerCase();
-  if (!scope || scope === "false" || scope === "off") return "";
-  if (["security", "policy", "coordination", "all"].includes(scope)) return scope;
-  return "all";
-}
-
-function warningMatchesScope(warning, scope) {
-  if (scope === "all") return true;
-  return warningScope(warning.code) === scope;
-}
-
-function warningScope(code = "") {
-  if (code === "security-vulnerabilities") return "security";
-  if (["conflicting-open-intents", "stale-open-intent", "handoff-stale"].includes(code)) return "coordination";
-  return "policy";
-}

package/src/commands/plan.js

@@ -7,6 +7,7 @@ import { renderPlan } from "../render.js";
 import { recommendedActions } from "../actions.js";
 import { openIntents, readJsonl, readTimeline } from "../timeline.js";
 import { aiDecision } from "../decision.js";
+import { enforcementAdvice } from "../enforcement.js";
 
 export async function planWorkspace(args) {
   const dir = workspaceDir(args);
@@ -41,6 +42,7 @@ export function buildPlan(manifest, warnings = [], intents = [], policy = {}) {
     workspace: manifest.workspace || {},
     trust: manifest.trust || {},
     decision: aiDecision(warnings, intents),
+    enforcement: enforcementAdvice(warnings),
     policy: {
       node: policy.node || "not set",
       python: policy.python || "not set",

package/src/commands/status.js

@@ -0,0 +1,53 @@
+import { diagnose } from "../doctor.js";
+import { readJson } from "../fsutil.js";
+import { loadPolicy, policyWarnings } from "../policy.js";
+import { intentsPath, manifestPath, timelinePath, workspaceDir } from "../paths.js";
+import { openIntents, readJsonl, readTimeline } from "../timeline.js";
+import { recommendedActions } from "../actions.js";
+import { aiDecision } from "../decision.js";
+import { enforcementAdvice } from "../enforcement.js";
+
+export async function statusWorkspace(args) {
+  const dir = workspaceDir(args);
+  const manifest = await readJson(manifestPath(dir));
+  if (!manifest) throw new Error("missing manifest; run `aienvmp sync` first");
+  const policy = await loadPolicy(dir);
+  const timeline = await readTimeline(timelinePath(dir));
+  const intents = openIntents(await readJsonl(intentsPath(dir)));
+  const warnings = [...diagnose(manifest, { timeline, intents }), ...policyWarnings(manifest, policy)];
+  const status = buildStatus(manifest, warnings, intents);
+  if (args.json) {
+    console.log(JSON.stringify(status, null, 2));
+  } else {
+    console.log(`${status.state}: ${status.summary}`);
+    console.log(`next: ${status.nextCommand}`);
+    console.log(`strict: ${status.enforcement.recommendedCommand}`);
+  }
+  return status;
+}
+
+export function buildStatus(manifest = {}, warnings = [], intents = []) {
+  const decision = aiDecision(warnings, intents);
+  const enforcement = enforcementAdvice(warnings);
+  const actions = recommendedActions(manifest, { warnings, intents });
+  const state = decision.reviewRequired ? "review-required" : "clear";
+  const topAction = actions[0] || null;
+  return {
+    schemaVersion: 1,
+    state,
+    summary: state === "clear"
+      ? "Project-local work can continue. Record intent before environment changes."
+      : "Review warnings or open intents before environment changes.",
+    decision,
+    enforcement,
+    counts: {
+      warnings: warnings.length,
+      openIntents: intents.length,
+      runtimes: Object.keys(manifest.runtimes || {}).length,
+      dependencies: Number(manifest.dependencySnapshot?.summary?.packages || 0),
+      vulnerabilities: Number(manifest.security?.summary?.total || 0)
+    },
+    topAction,
+    nextCommand: topAction?.command || decision.nextCommand
+  };
+}

package/src/enforcement.js

@@ -0,0 +1,57 @@
+const STRICT_SCOPES = ["security", "policy", "coordination", "all"];
+
+export function strictResult(warnings = [], args = {}) {
+  const scope = normalizeStrictScope(args.strict || (args.ci ? "all" : ""));
+  const matchedWarnings = scope ? warnings.filter((warning) => warningMatchesScope(warning, scope)) : [];
+  return {
+    enabled: Boolean(scope),
+    scope: scope || "off",
+    fail: matchedWarnings.length > 0,
+    matchedWarningCodes: matchedWarnings.map((warning) => warning.code),
+    availableScopes: STRICT_SCOPES
+  };
+}
+
+export function enforcementAdvice(warnings = []) {
+  const scopeResults = STRICT_SCOPES.map((scope) => {
+    const result = strictResult(warnings, { strict: scope });
+    return {
+      scope,
+      status: result.fail ? "fail" : "pass",
+      matchedWarningCodes: result.matchedWarningCodes
+    };
+  });
+  const suggestedStrictScopes = scopeResults
+    .filter((item) => item.scope !== "all" && item.status === "fail")
+    .map((item) => item.scope);
+  return {
+    mode: "advisory-by-default",
+    localBehavior: "non-blocking",
+    ciBehavior: "strict-only-when-requested",
+    suggestedStrictScopes,
+    scopes: scopeResults,
+    recommendedCommand: suggestedStrictScopes.length
+      ? `aienvmp doctor --strict ${suggestedStrictScopes[0]}`
+      : "aienvmp doctor --strict all",
+    note: "Use strict mode in CI or explicit checks; do not block local operation unless the user requests it."
+  };
+}
+
+function normalizeStrictScope(value) {
+  if (value === true) return "all";
+  const scope = String(value || "").trim().toLowerCase();
+  if (!scope || scope === "false" || scope === "off") return "";
+  if (STRICT_SCOPES.includes(scope)) return scope;
+  return "all";
+}
+
+function warningMatchesScope(warning, scope) {
+  if (scope === "all") return true;
+  return warningScope(warning.code) === scope;
+}
+
+function warningScope(code = "") {
+  if (code === "security-vulnerabilities") return "security";
+  if (["conflicting-open-intents", "stale-open-intent", "handoff-stale"].includes(code)) return "coordination";
+  return "policy";
+}

package/src/render.js

@@ -95,6 +95,7 @@ export function renderContext(manifest, timeline = [], warnings = [], intents =
     `Status: ${status}`,
     `Next: ${next}`,
     "Project-local work: allowed; environment changes require intent and review when warnings or open intents exist.",
+    "Enforcement: advisory by default; use `aienvmp doctor --strict <scope>` only when explicit CI failure is wanted.",
     `Trust: ${manifest.trust?.state || "observed"} (verified requires human or CI)`,
     `Workspace: ${manifest.workspace.path}`,
     `Node: ${manifest.runtimes.node || "not detected"}`,
@@ -175,6 +176,7 @@ export function renderPlan(plan) {
     "",
     `Status: ${plan.status}`,
     `Decision: ${plan.decision?.mode || plan.status}`,
+    `Enforcement: ${plan.enforcement?.mode || "advisory-by-default"} (${plan.enforcement?.localBehavior || "non-blocking"})`,
     `Generated: ${plan.generatedAt}`,
     `Workspace: ${plan.workspace?.path || "unknown"}`,
     "",