vgxness 1.18.0 → 1.19.0

package/dist/agents/agent-lookup-contexts.js

@@ -0,0 +1,28 @@
+export const GLOBAL_PERSONAL_AGENTS_PROJECT = '__personal__';
+export const GLOBAL_VGXNESS_AGENTS_PROJECT = '__vgxness__';
+export const LEGACY_VGXNESS_AGENTS_PROJECT = 'vgxness';
+export const agentLookupContexts = (project, scope) => {
+    const contexts = [{ project, scope }];
+    if (scope !== 'personal')
+        contexts.push({ project, scope: 'personal' });
+    if (project !== GLOBAL_PERSONAL_AGENTS_PROJECT)
+        contexts.push({ project: GLOBAL_PERSONAL_AGENTS_PROJECT, scope: 'personal' });
+    if (project !== GLOBAL_VGXNESS_AGENTS_PROJECT)
+        contexts.push({ project: GLOBAL_VGXNESS_AGENTS_PROJECT, scope: 'project' });
+    if (project !== LEGACY_VGXNESS_AGENTS_PROJECT)
+        contexts.push({ project: LEGACY_VGXNESS_AGENTS_PROJECT, scope: 'project' });
+    return dedupeContexts(contexts);
+};
+export const dedupeAgentLookupContexts = (contexts) => {
+    return dedupeContexts(contexts);
+};
+function dedupeContexts(contexts) {
+    const seen = new Set();
+    return contexts.filter((context) => {
+        const key = `${context.project}:${context.scope}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}

package/dist/agents/agent-registry-service.js

@@ -1,3 +1,4 @@
+import { agentLookupContexts } from './agent-lookup-contexts.js';
 import { AgentResolver } from './agent-resolver.js';
 import { AgentRepository } from './repositories/agents.js';
 export class AgentRegistryService {
@@ -32,9 +33,9 @@ export class AgentRegistryService {
         this.database.close();
     }
     listAgentDefinitions(input) {
-        const filters = {};
         if (input.project !== undefined)
-            filters.project = input.project;
+            return this.listAgentDefinitionsForContexts(input);
+        const filters = {};
         if (input.scope !== undefined)
             filters.scope = input.scope;
         if (input.mode !== undefined)
@@ -51,4 +52,30 @@ export class AgentRegistryService {
         }
         return { ok: true, value: definitions };
     }
+    listAgentDefinitionsForContexts(input) {
+        const project = input.project;
+        if (project === undefined)
+            return { ok: true, value: [] };
+        const summariesByName = new Map();
+        for (const context of agentLookupContexts(project, input.scope ?? 'project')) {
+            const filters = { project: context.project, scope: context.scope };
+            if (input.mode !== undefined)
+                filters.mode = input.mode;
+            const summaries = this.agents.list(filters);
+            if (!summaries.ok)
+                return summaries;
+            for (const summary of summaries.value) {
+                if (!summariesByName.has(summary.name))
+                    summariesByName.set(summary.name, summary);
+            }
+        }
+        const definitions = [];
+        for (const summary of summariesByName.values()) {
+            const agent = this.agents.getById(summary.id);
+            if (!agent.ok)
+                return agent;
+            definitions.push(agent.value);
+        }
+        return { ok: true, value: definitions };
+    }
 }

package/dist/agents/agent-resolver.js

@@ -1,4 +1,5 @@
 import { normalizeSddPhaseInput } from '../sdd/schema.js';
+import { agentLookupContexts } from './agent-lookup-contexts.js';
 export class AgentResolver {
     loadAgents;
     constructor(loadAgents) {
@@ -59,9 +60,13 @@ function normalizeInput(input) {
     const desiredCapabilities = normalizeList(input.desiredCapabilities ?? []);
     const taskDescription = normalizeText(input.taskDescription);
     const intent = normalizeText(input.intent);
-    const phase = input.phase === undefined ? undefined : (isSddWorkflow(input.workflow) ? (normalizeSddPhaseInput(input.phase) ?? input.phase) : input.phase);
+    const metaWorkflow = isMetaWorkflow(input.workflow);
+    const workflow = normalizeMetaWorkflow(input.workflow);
+    const phase = metaWorkflow || input.phase === undefined ? undefined : (isSddWorkflow(workflow) ? (normalizeSddPhaseInput(input.phase) ?? input.phase) : input.phase);
+    const { workflow: _workflow, phase: _phase, ...rest } = input;
     return {
-        ...input,
+        ...rest,
+        ...(workflow !== undefined ? { workflow } : {}),
         ...(phase !== undefined ? { phase } : {}),
         ...(taskDescription !== undefined ? { taskDescription } : {}),
         ...(intent !== undefined ? { intent } : {}),
@@ -69,11 +74,19 @@ function normalizeInput(input) {
         terms: tokenize([taskDescription, intent].filter((value) => value !== undefined).join(' ')),
     };
 }
+function normalizeMetaWorkflow(workflow) {
+    if (isMetaWorkflow(workflow))
+        return undefined;
+    return workflow;
+}
+function isMetaWorkflow(workflow) {
+    return workflow?.trim().toLowerCase() === 'workflow-selection';
+}
 function hardSkipReasons(agent, input) {
     const reasons = [];
-    if (input.project !== undefined && agent.project !== input.project)
-        reasons.push(`project mismatch: ${agent.project}`);
-    if (input.scope !== undefined && agent.scope !== input.scope)
+    if (input.project !== undefined && !agentMatchesRequestedContext(agent, input))
+        reasons.push(`context mismatch: ${agent.project}/${agent.scope}`);
+    else if (input.project === undefined && input.scope !== undefined && agent.scope !== input.scope)
         reasons.push(`scope mismatch: ${agent.scope}`);
     if (input.mode !== undefined && agent.mode !== input.mode)
         reasons.push(`mode mismatch: ${agent.mode}`);
@@ -85,6 +98,12 @@ function hardSkipReasons(agent, input) {
         reasons.push('capability mismatch');
     return reasons;
 }
+function agentMatchesRequestedContext(agent, input) {
+    if (input.project === undefined)
+        return true;
+    const contexts = agentLookupContexts(input.project, input.scope ?? 'project');
+    return contexts.some((context) => agent.project === context.project && agent.scope === context.scope);
+}
 function scoreAgent(agent, input) {
     const reasons = [];
     let score = 0;

package/dist/agents/agent-selector-resolver.js

@@ -1,20 +1,25 @@
+import { agentLookupContexts } from './agent-lookup-contexts.js';
 export const agentSelectorNameFallbackCode = 'AGENT_SELECTOR_NAME_FALLBACK';
 export function resolveAgentSelector(input, lookup) {
     const byId = lookup.getById(input.selector);
     if (byId.ok)
         return ok({ agent: byId.value });
-    const byName = lookup.getByName(input.project, input.scope, input.selector);
-    if (byName.ok) {
-        return ok({
-            agent: byName.value,
-            warning: `${agentSelectorNameFallbackCode}: selector "${input.selector}" matched scoped agent name; using canonical agent id "${byName.value.id}" name "${byName.value.name}".`,
-        });
+    for (const context of agentLookupContexts(input.project, input.scope)) {
+        const byName = lookup.getByName(context.project, context.scope, input.selector);
+        if (byName.ok) {
+            return ok({
+                agent: byName.value,
+                warning: `${agentSelectorNameFallbackCode}: selector "${input.selector}" matched agent name in ${context.project}/${context.scope}; using canonical agent id "${byName.value.id}" name "${byName.value.name}".`,
+            });
+        }
+        if (byName.error.code !== 'not_found')
+            return byName;
     }
     return {
         ok: false,
         error: {
             code: 'not_found',
-            message: `Agent selector not found: "${input.selector}". Looked up registry id first, then scoped agent name for project "${input.project}" and scope "${input.scope}". Accepted forms: canonical agent id or agent name within the requested project/scope.`,
+            message: `Agent selector not found: "${input.selector}". Looked up registry id first, then agent name across project, personal, and VGXNESS global contexts for project "${input.project}" and scope "${input.scope}". Accepted forms: canonical agent id or visible agent name.`,
         },
     };
 }

package/dist/agents/canonical-agent-manifest.js

@@ -2,7 +2,7 @@ import { canonicalBehaviorContractVersion } from '../behavior/behavior-contract-
 export const canonicalDefaultAgentName = 'vgxness-manager';
 export const canonicalOpenCodeDefaultModel = 'openai/gpt-5.5';
 export const canonicalOpenCodeManagerReasoningEffort = 'high';
-export const canonicalPromptContractVersion = 12;
+export const canonicalPromptContractVersion = 15;
 export const canonicalSddSubagentNames = [
     'vgxness-sdd-explore',
     'vgxness-sdd-propose',
@@ -79,7 +79,7 @@ function managerDefinition() {
         name: canonicalDefaultAgentName,
         description: 'Coordinates VGXNESS MCP state and SDD sub-agents while routing Tier 0-2 lightweight work, Tier 3 preflight validation, and Tier 4 formal SDD.',
         instructions: { kind: 'inline', value: registryManagerInstructionsV11 },
-        capabilities: ['sdd-orchestration', 'agent-routing', 'mcp-coordination', 'project-local-automation'],
+        capabilities: ['sdd-orchestration', 'agent-routing', 'mcp-coordination', 'project-local-automation', 'coordination', 'workflow-selection', 'resume'],
         permissions: { read: 'allow', edit: 'ask', shell: 'ask', git: 'ask', memory: 'allow', 'provider-tool': 'deny', secrets: 'deny' },
         memory: { scopes: ['project'] },
         workflows: ['explore', 'quickfix', 'plan', 'build', 'debug', 'sdd', 'agent-seeding', 'opencode-install'],
@@ -165,25 +165,27 @@ Coordinate SDD; keep chat thin, use VGXNESS MCP state, delegate to exact SDD sub
 - SDD artifact acceptance is human-only. Artifact presence is not acceptance. Never infer or fabricate acceptance from generated output, subagent/model output, file presence, confidence, or legacy artifacts; draft/rejected/superseded/stale/unaccepted artifacts are not accepted until a human acceptance record exists.
 - Before phase advancement, call \`vgxness_sdd_status\`/\`vgxness_sdd_next\` plus \`vgxness_sdd_ready\` or \`vgxness_sdd_get_readiness\`.
 - Before risky VGX-managed side effects (edit, shell/tests, git, network, provider-tool, secrets, external-directory, destructive, privileged, ambiguous), call \`vgxness_run_preflight\` with runId/workflow/phase/agent when available. Stop on approval/block; never invent approval.
-- Direct human acceptance of an exact SDD artifact via \`vgxness_sdd_accept_artifact\` is not a generic SDD write for manager routing: do not call \`vgxness_run_preflight\` solely for that acceptance; require the user explicitly accepted the exact project/change/phase artifact, \`acceptedBy.type\` is \`"human"\`, \`acceptedBy.id\` is non-empty, and status/readiness confirms the artifact is eligible. This shortcut applies only to \`vgxness_sdd_accept_artifact\` and the trusted draft autorun chain described below; excludes edits, shell/tests, git, provider config, memory writes, external paths, secrets, destructive/privileged/ambiguous operations.
-- OpenCode native/provider tools are governance-v1 audit-only/non-hard-blocking. Report warnings; do not say native OpenCode tools are hard-blocked by config.
+- Direct human acceptance via \`vgxness_sdd_accept_artifact\` is not a generic SDD write: do not preflight solely for it; require exact project/change/phase, \`acceptedBy.type\` \`"human"\`, non-empty \`acceptedBy.id\`, and eligible status/readiness. Shortcut only for acceptance/trusted draft autorun; excludes edits, shell/tests, git, provider config, memory writes, external paths, secrets, destructive/privileged/ambiguous operations.
+- manager native repo tools are disabled in config (read/glob/edit/write/bash); report config-level enforcement, not proof of host runtime behavior. Subagents keep phase tools.
 - Do not mutate provider/global OpenCode config. Do not publish packages unless explicitly requested. Never revert/overwrite unrelated user work. Preserve \`permission.task\` deny-by-default with only exact known SDD subagents.
 - Do not change provider model/reasoning config unless explicitly requested.
 
-## Flexible governance routing
-Use lightest safe path: T0-2 direct, T3 preflight, T4 formal SDD for governance, permissions, acceptance, architecture/security, or cross-surface behavior. Provider status/doctor/preview/handoff read-only/audit-only; writes gated.
+## Routing
+Use lightest safe path: T0-2 direct, T3 preflight, T4 SDD for governance/permissions/acceptance/architecture/security/cross-surface behavior. Provider status/doctor/preview/handoff read-only/audit-only; writes gated.
 
 ## Provider-native daily flow
 SDD happens in OpenCode via conversation, VGXNESS MCP, and SDD subagents. No terminal SDD phase commands. CLI is an escape hatch for bootstrap, doctor, recovery, setup gaps, or explicit request.
 
 ## MCP playbook
-- For starting, resuming, or recovering context: prefer \`vgxness_context_cockpit\`; treat \`vgxness_session_restore\` as one signal, not truth. For ending, pausing, handing off, or compacting: \`vgxness_session_close\` with session id and actor \`manager\`; if no id, do not invent one and summarize.
+- For starting, resuming, or recovering context: prefer \`vgxness_context_cockpit\`; \`vgxness_session_restore\` is one signal, not truth. For ending, pausing, handing off, or compacting: \`vgxness_session_close\` with id and actor \`manager\`; if no id, do not invent one; summarize.
+- Bounded resume/start hard stop: for "continue"/"sigamos"/"resume development", call compact \`vgxness_skill_payload\`, \`vgxness_context_cockpit\`, \`vgxness_run_resume_candidates\`, then \`vgxness_agent_resolve\` only if an executor is needed. If no interrupted run or exact SDD change/next action exists, stop: do not use Glob/Read/docs, do not inspect repo files, do not delegate to SDD subagents, do not start runs; return status and ask one question: "¿qué cambio retomamos?". \`skill_index\`/\`skill_search\` are not resume fallback.
 - Proposal clarity: if product/business clarity is missing, run a proposal question round.
 - SDD artifacts: guide with \`vgxness_sdd_next\`/\`vgxness_sdd_cockpit\`; list/read with \`vgxness_sdd_get_artifact\`/\`vgxness_sdd_list_artifacts\`; prefer \`payloadMode: "compact"\` so primary context stays clean; use verbose only when required, preferably inside the delegated phase subagent. Save with \`vgxness_sdd_save_artifact\` after the right flow. Use \`vgxness_sdd_reopen_artifact\` only for rejected artifacts returning to draft, with explicit human actor/audit context.
-- Trusted draft autorun: when the exact \`proposal\` artifact is already accepted, run exactly \`spec -> design -> tasks\` without extra human confirmation via exact subagents; save drafts with \`vgxness_sdd_save_artifact\`. This is draft-only planning, not acceptance or completion. Not for explore/proposal/apply-progress/verify/archive, rejected/superseded artifacts, accepted overwrites, or risky side effects (provider config, edits, shell/tests, git, secrets, external/destructive/privileged/ambiguous). Re-check status/readiness before/after; generated spec/design drafts can feed design/tasks but remain unaccepted.
-- Acceptance/readiness: check SDD status/readiness for the exact project/change/phase; confirm explicit human acceptance; call \`vgxness_sdd_accept_artifact\` directly with audit context (\`acceptedBy.type: "human"\`, non-empty \`acceptedBy.id\`, runId, agentId); re-check status/readiness before reporting state. Do not add \`vgxness_run_preflight\` solely for that exact direct acceptance call. Ambiguous replies count only when tied to an immediate exact acceptance prompt. Use \`vgxness_governance_report\` for readiness, artifact states, preflight posture, audit warnings.
-- Memory: \`vgxness_memory_search\`/\`vgxness_memory_get\` for prior work/unclear context; \`vgxness_memory_save\` for durable discoveries, decisions, bug fixes, config, patterns, or preferences; \`vgxness_memory_update\` only to correct/evolve a known id. Do not duplicate full SDD artifacts as memory.
-- Agents/skills: Skill registry index-first; resolve skills by registry, exact path, and task context; read exact paths; do not invent summaries. Resolve phase with \`vgxness_agent_resolve\`. Preview mode does not execute a provider or write provider config for \`vgxness_agent_activate\`, \`vgxness_opencode_manager_payload\`, or \`vgxness_skill_payload\`. \`vgxness_manager_profile_get\` before changes; \`vgxness_manager_profile_set\` needs explicit human authorization.
+- Trusted draft autorun: when the exact \`proposal\` artifact is already accepted, run \`spec -> design -> tasks\` without extra human confirmation via subagents; save drafts with \`vgxness_sdd_save_artifact\`. This is draft-only planning, not acceptance or completion. Excludes explore/proposal/apply-progress/verify/archive, accepted overwrites, risky side effects; re-check status/readiness.
+- Acceptance/readiness: check exact status/readiness; confirm explicit human acceptance; call \`vgxness_sdd_accept_artifact\` directly with audit context (\`acceptedBy.type: "human"\`, non-empty \`acceptedBy.id\`, runId, agentId); re-check before reporting. Do not preflight solely for exact acceptance. Ambiguous replies count only when tied to an immediate exact acceptance prompt. Use \`vgxness_governance_report\` for readiness, artifact states, preflight posture, audit warnings.
+- Memory: \`vgxness_memory_search\`/\`vgxness_memory_get\` for prior work/unclear context; \`vgxness_memory_save\` for durable discoveries/decisions/bug fixes/config/patterns/preferences; \`vgxness_memory_update\` only for a known id. Do not duplicate full SDD artifacts as memory.
+- Active-work memory uses existing memory APIs only: \`active-work/{change}/summary\` (+others). No secrets or hidden reasoning. Active-work memory is advisory only; never proves SDD acceptance/readiness, verification, or authorization.
+- Agents/skills: Use \`vgxness_skill_payload\` first for contextual skill guidance; preview/context-only, no provider execution or config writes. Use \`vgxness_skill_index\`/\`vgxness_skill_search\` only for explicit diagnostics/catalog, not normal resume fallback. Resolve phase with \`vgxness_agent_resolve\`; if none resolves, report evidence and ask for the smallest decision instead of inventing agent ids. \`vgxness_agent_activate\` and \`vgxness_opencode_manager_payload\` are preview/context-only. \`vgxness_manager_profile_get\` before changes; \`vgxness_manager_profile_set\` needs explicit human authorization.
 - Runs/recovery: \`vgxness_run_start\`/\`vgxness_run_list\`/\`vgxness_run_get\`; checkpoint with \`vgxness_run_checkpoint\`, preflight with \`vgxness_run_preflight\`, close with \`vgxness_run_finalize\`. Unknown runId: \`vgxness_run_resume_candidates\`. For interrupted runs, inspect with \`vgxness_run_resume_inspect\`, then call \`vgxness_run_resume_gate\` with approvalId from pendingApprovals/inspect; never pass runId as approvalId. Follow safe \`recommendedActions[]\`.
 - Provider diagnostics: \`vgxness_provider_status\`/\`vgxness_provider_doctor\` read-only; report \`providerEvidence.evidenceLevel\` and \`hostToolPresenceVerified\` limits.
 
@@ -209,6 +211,7 @@ const registryManagerInstructionsV11 = [
     'You are the VGXNESS SDD coordinator, not a monolithic executor. Coach briefly while coordinating: explain useful tradeoffs, be realistic about risks and unknowns, respectfully challenge weak assumptions with better options, keep the user comfortable and in control, and stay concise.',
     'Default to delegation for SDD phase-shaped work, repository exploration beyond one narrow lookup, implementation, verification, incident recovery, or multi-step analysis. Inline only conversational guidance, single-fact lookup, MCP/status/readiness checks, and trivial mechanical edits when safe. When uncertain between inline work and subagent work, delegate to the exact smallest SDD subagent.',
     'Use VGXNESS MCP as the durable control plane: restore session context with vgxness_session_restore before inferring start/resume state from chat, and close/pause/compact with vgxness_session_close using actor manager plus an actionable summary when a current session id exists.',
+    'For continue/sigamos/resume development, run only bounded resume/start: compact skill_payload, context_cockpit, run_resume_candidates, then agent_resolve only if needed. If no interrupted run or exact SDD change/next action exists, hard stop: do not use Glob/Read/docs, inspect repo files, delegate to SDD subagents, start runs, use skill_index/skill_search fallback, or invent agent ids; summarize status and ask one question: "¿qué cambio retomamos?".',
     'Check SDD status/next/ready/cockpit, read prerequisites with sdd_get_artifact or sdd_list_artifacts, use public sdd_continue/internal vgxness_sdd_continue first for advisory read-only continuation plans, use sdd_reopen_artifact only for rejected artifacts returning to draft with explicit human actor/audit context, save phase output with sdd_save_artifact only by governance; when proposal is accepted, spec/design/tasks may run sequentially as draft-only autorun without extra confirmation, while acceptance remains human-only. Search/get/save/update memory only for reusable knowledge, resolve exact SDD subagents before substantial phase work, use runs/checkpoints/preflight/finalize for significant implementation or verification, use run_resume_candidates for unknown runId, inspect interrupted runs by runId with run_resume_inspect, then call run_resume_gate with approvalId from pendingApprovals/inspect; never pass runId as approvalId; use vgxness_provider_status for configured/phase/next questions plus vgxness_provider_doctor for read-only OpenCode MCP/manager health.',
     'When sdd_continue/vgxness_sdd_continue returns recommendedActions, prefer the first safe action with agentCallable true and humanOnly false; use targetTool plus suggestedArgs as the starting point, and stop for requiresHumanConfirmation, requiresProviderWriteConsent, requiresPreflight, ambiguous, destructive, privileged, external, or outside-approval actions. For readiness, use cockpit/status/readiness to distinguish missing, draft, ready, blocked, and accepted; never infer acceptance. For provider evidence, report providerEvidence.evidenceLevel, hostToolPresenceVerified, notes, and limitations; do not claim true host presence unless evidence explicitly verifies it.',
     'Prefer payloadMode=compact for manager-facing status/context reads, SDD artifact reads/lists, and activation handoffs so the primary context stays clean; request payloadMode=verbose only when full artifact contents, provider payloads, or skill context are actually needed, preferably inside delegated phase subagents.',

package/dist/agents/canonical-agent-projection.js

@@ -20,10 +20,10 @@ export function projectCanonicalAgentManifestToOpenCode(manifest = canonicalAgen
             mode: 'primary',
             ...(manager.adapters?.opencode?.model !== undefined ? { model: manager.adapters.opencode.model } : {}),
             options: { reasoningEffort: canonicalOpenCodeManagerReasoningEffort, vgxnessPromptContractVersion: canonicalPromptContractVersion },
-            permission: { ...openCodePermissionsFor(manager, { task: createCanonicalOpenCodeSddTaskPermissions() }), bash: 'allow' },
+            permission: openCodeManagerPermissionsFor(manager),
             prompt: canonicalOpenCodeManagerPrompt,
             reasoningEffort: canonicalOpenCodeManagerReasoningEffort,
-            tools: { bash: true, delegate: true, delegation_list: true, delegation_read: true, edit: true, read: true, write: true },
+            tools: openCodeManagerTools(),
             variant: '',
         },
     };
@@ -132,6 +132,28 @@ function openCodePermissionsFor(agent, additional = {}) {
     const adapterPermission = asRecord(agent.adapters?.opencode?.config?.permission);
     return { ...adapterPermission, ...additional, ...mapCanonicalPermissionsToOpenCode(agent.permissions) };
 }
+function openCodeManagerPermissionsFor(agent) {
+    return {
+        ...openCodePermissionsFor(agent, { task: createCanonicalOpenCodeSddTaskPermissions() }),
+        bash: 'deny',
+        edit: 'deny',
+        read: 'deny',
+        write: 'deny',
+    };
+}
+function openCodeManagerTools() {
+    return {
+        bash: false,
+        delegate: true,
+        delegation_list: true,
+        delegation_read: true,
+        edit: false,
+        glob: false,
+        grep: false,
+        read: false,
+        write: false,
+    };
+}
 function mapCanonicalPermissionsToOpenCode(permissions) {
     const mapped = {};
     if (permissions === undefined)

package/dist/cli/cli-help.js

@@ -69,7 +69,7 @@ Areas:
   mcp doctor [--db <path>] [--project <name>] [--change <id>] [--timeout-ms <ms>]
   MCP setup preview is read-only; it does not install or write .opencode/, .claude/, or provider config.
   Without --db, MCP install and setup commands use the vgxness global default database; pass --db .vgx/memory.sqlite for project-local compatibility.
-  OpenCode install defaults to user-global scope and installs mcp.vgxness plus top-level permission.bash=ask, vgxness-manager with bash=allow, and hidden vgxness-sdd-* agents with explicit permissions; use --mcp-only for legacy MCP-only config.
+  OpenCode install defaults to user-global scope and installs mcp.vgxness plus top-level permission.bash=ask, vgxness-manager with bash=deny and native repo tools disabled, and hidden vgxness-sdd-* agents with explicit permissions; use --mcp-only for legacy MCP-only config.
   Use --overwrite-vgxness (alias --reinstall) to reinstall only VGXNESS-managed OpenCode entries while preserving unrelated config; --yes is still required to write.
   It writes only after --yes. VGX-managed provider configuration is user-global only for OpenCode and Claude; the OpenCode target is $HOME/.config/opencode/opencode.json.
   Project/local provider files are external/manual diagnostics and will not be written by VGXNESS. Plans are read-only; applies refuse unsafe existing user-global config and create backups before merge.

package/dist/cli/home-tui-app.js

@@ -365,7 +365,7 @@ function focusedProviderLines(plan) {
     ];
 }
 function bashPolicySummary(policy) {
-    return policy.manager === 'allow' ? `${policy.topLevel} globally, allow for VGXNESS manager` : policy.topLevel;
+    return policy.manager === 'deny' ? `${policy.topLevel} globally, deny for VGXNESS manager` : policy.topLevel;
 }
 function summaryItems(plan) {
     const ready = plan.status === 'ready';

package/dist/mcp/client-install-opencode-contract.js

@@ -197,7 +197,7 @@ function warningsForScope(scope, overwriteVgxness, agentPlan, bashPermissionPoli
             `Reinstall/overwrite is enabled: existing VGXNESS-managed OpenCode entries will be replaced (${agentPlan.installsAgents ? 'mcp.vgxness, default_agent, instructions AGENTS.md, and known VGXNESS agents' : 'mcp.vgxness only'}); unrelated OpenCode config is preserved.`,
         ]
         : [];
-    const bashWarnings = bashPermissionPolicy.manager === 'allow' ? ['OpenCode top-level permission.bash is set to ask; the VGXNESS manager agent allows bash while SDD subagents keep explicit permissions.'] : ['OpenCode top-level permission.bash is set to ask.'];
+    const bashWarnings = bashPermissionPolicy.manager === 'deny' ? ['OpenCode top-level permission.bash is set to ask; the VGXNESS manager agent denies bash while SDD subagents keep explicit phase permissions.'] : ['OpenCode top-level permission.bash is set to ask.'];
     return [
         'Restart OpenCode after installation so it reloads the user MCP config.',
         'OpenCode project config may override user config for a workspace; check project-level config if vgxness is not visible.',
@@ -206,7 +206,7 @@ function warningsForScope(scope, overwriteVgxness, agentPlan, bashPermissionPoli
     ];
 }
 function bashPermissionPolicyFor(agentPlan) {
-    return agentPlan.installsAgents ? { topLevel: 'ask', manager: 'allow' } : { topLevel: 'ask' };
+    return agentPlan.installsAgents ? { topLevel: 'ask', manager: 'deny' } : { topLevel: 'ask' };
 }
 function createdConfigKeys(agentPlan) {
     const keys = agentPlan.installsAgents ? ['$schema', 'instructions', 'default_agent', 'agent', 'mcp'] : ['$schema', 'mcp'];

package/dist/mcp/client-install-opencode.js

@@ -214,7 +214,7 @@ function confirmationRequiredMessage(scope) {
     return `\`mcp install opencode\` requires explicit --yes before any ${scope} config write.`;
 }
 function warnings() {
-    return ['Restart OpenCode after installation so it reloads the project MCP config.', 'OpenCode top-level permission.bash is set to ask; the VGXNESS manager agent allows bash while SDD subagents keep explicit permissions.'];
+    return ['Restart OpenCode after installation so it reloads the project MCP config.', 'OpenCode top-level permission.bash is set to ask; the VGXNESS manager agent denies bash while SDD subagents keep explicit phase permissions.'];
 }
 function manualTest(databasePath, source) {
     return {
@@ -231,5 +231,5 @@ function defaultVerificationHints(databasePath, source) {
     ];
 }
 function bashPermissionPolicyFor(agentPlan) {
-    return agentPlan.installsAgents ? { topLevel: 'ask', manager: 'allow' } : { topLevel: 'ask' };
+    return agentPlan.installsAgents ? { topLevel: 'ask', manager: 'deny' } : { topLevel: 'ask' };
 }

package/dist/mcp/control-plane-snapshot-service.js

@@ -1,3 +1,4 @@
+import { ActiveWorkPreviewService } from '../memory/active-work-preview.js';
 import { ContextBudgetService } from '../payload/context-budget-service.js';
 export const contextCockpitSnapshotLevels = ['compact', 'expanded', 'verbose'];
 export class ContextCockpitSnapshotService {
@@ -22,11 +23,21 @@ export class ContextCockpitSnapshotService {
             return sddResult;
         const sdd = sddResult?.value;
         const integratesSdd = sdd !== undefined;
+        const searchObservationPreviewsNoTrace = this.dependencies.memory.searchObservationPreviewsNoTrace === undefined
+            ? (() => ({ ok: true, value: [] }))
+            : (filters) => this.dependencies.memory.searchObservationPreviewsNoTrace(filters);
+        const activeWorkResult = new ActiveWorkPreviewService({
+            searchObservationPreviewsNoTrace,
+        }).build({ project: input.project, ...(input.change === undefined ? {} : { change: input.change }) });
+        if (!activeWorkResult.ok)
+            return activeWorkResult;
+        const activeWork = activeWorkResult.value;
         const optionalSectionsOmitted = omittedSections(legacy.value.optionalSectionsOmitted, integratesSdd ? ['provider'] : ['sdd', 'provider'], integratesSdd ? ['sdd'] : []);
         const snapshotWithoutBudget = {
             ...legacy.value,
             optionalSectionsOmitted,
             ...(sdd === undefined ? {} : { sdd }),
+            ...(activeWork.items.length === 0 && activeWork.change === undefined ? {} : { activeWork }),
             snapshotVersion: 2,
             level,
             references: [

package/dist/memory/active-work-preview.js

@@ -0,0 +1,75 @@
+import { activeWorkCurrentSegments, activeWorkRecommendedMemoryTypes, activeWorkTopicRoot, parseActiveWorkTopicKey } from './active-work-topics.js';
+const sourceLimit = 50;
+const maxItems = 8;
+const maxPreviewChars = 160;
+const currentPriority = new Map(activeWorkCurrentSegments.map((segment, index) => [segment, index]));
+export class ActiveWorkPreviewService {
+    source;
+    constructor(source) {
+        this.source = source;
+    }
+    build(input) {
+        const found = this.source.searchObservationPreviewsNoTrace({ project: input.project, topicKey: activeWorkTopicRoot, limit: sourceLimit });
+        if (!found.ok)
+            return found;
+        return { ok: true, value: formatActiveWorkPreview(found.value, input.change) };
+    }
+}
+export function formatActiveWorkPreview(records, change) {
+    const parsed = records
+        .map((record) => ({ record, parsed: parseActiveWorkTopicKey(record.topicKey) }))
+        .filter((entry) => entry.parsed !== undefined)
+        .filter((entry) => change === undefined || entry.parsed.change === change);
+    const changes = [...new Set(parsed.map((entry) => entry.parsed.change))].sort();
+    const notes = [
+        'Active-work memory is advisory only; canonical SDD status/readiness, runs, artifacts, and explicit human acceptance remain authoritative.',
+        'Previews are bounded and may omit full context; use memory_get for a selected memory when safe.',
+        'Do not store secrets, credentials, raw large logs, hidden reasoning, or sensitive user data in active-work memory.',
+    ];
+    if (change === undefined && changes.length > 1) {
+        return {
+            advisory: true,
+            items: [],
+            truncated: true,
+            notes: [...notes, `Multiple active-work changes found (${changes.join(', ')}); provide an explicit change to avoid mixing narratives.`],
+        };
+    }
+    const resolvedChange = change ?? changes[0];
+    const candidates = parsed.filter((entry) => resolvedChange === undefined || entry.parsed.change === resolvedChange).sort(compareActiveWorkEntries);
+    const items = candidates.slice(0, maxItems).map(({ record }) => toPreviewItem(record));
+    const truncated = candidates.length > items.length || records.length >= sourceLimit;
+    return {
+        advisory: true,
+        ...(resolvedChange === undefined ? {} : { change: resolvedChange }),
+        items,
+        truncated,
+        notes: items.length === 0 ? [...notes, 'No active-work memory found for this context.'] : notes,
+    };
+}
+function compareActiveWorkEntries(left, right) {
+    const leftPriority = currentPriority.get(left.parsed.segment) ?? 100;
+    const rightPriority = currentPriority.get(right.parsed.segment) ?? 100;
+    if (leftPriority !== rightPriority)
+        return leftPriority - rightPriority;
+    const expectedLeft = activeWorkRecommendedMemoryTypes[left.parsed.segment] === left.record.type ? 0 : 1;
+    const expectedRight = activeWorkRecommendedMemoryTypes[right.parsed.segment] === right.record.type ? 0 : 1;
+    if (expectedLeft !== expectedRight)
+        return expectedLeft - expectedRight;
+    return right.record.updatedAt.localeCompare(left.record.updatedAt);
+}
+function toPreviewItem(record) {
+    return {
+        id: record.id,
+        topicKey: record.topicKey ?? '',
+        title: record.title,
+        type: record.type,
+        preview: redactSensitivePreview(record.preview).slice(0, maxPreviewChars),
+        ...(record.updatedAt === undefined ? {} : { updatedAt: record.updatedAt }),
+    };
+}
+function redactSensitivePreview(value) {
+    return value
+        .replace(/\b([A-Za-z0-9._%+-]+)@([A-Za-z0-9.-]+\.[A-Za-z]{2,})\b/g, '[redacted-email]')
+        .replace(/\b(api[_-]?key|token|secret|password|credential)\s*[:=]\s*\S+/gi, '$1=[redacted]')
+        .replace(/\b(sk-[A-Za-z0-9_-]{8,}|ghp_[A-Za-z0-9_]{8,})\b/g, '[redacted-token]');
+}

package/dist/memory/active-work-topics.js

@@ -0,0 +1,50 @@
+export const activeWorkTopicRoot = 'active-work';
+export const activeWorkCurrentSegments = ['summary', 'progress', 'next', 'blockers'];
+export const activeWorkDetailSegments = ['decision', 'discovery', 'bugfix', 'config'];
+export const activeWorkRecommendedMemoryTypes = {
+    summary: 'manual',
+    progress: 'manual',
+    next: 'manual',
+    blockers: 'manual',
+    decision: 'decision',
+    discovery: 'discovery',
+    bugfix: 'bugfix',
+    config: 'config',
+};
+export function activeWorkTopicPrefix(change) {
+    return `${activeWorkTopicRoot}/${normalizeTopicPart(change)}`;
+}
+export function activeWorkCurrentTopic(change, segment) {
+    return `${activeWorkTopicPrefix(change)}/${segment}`;
+}
+export function activeWorkDetailTopic(change, segment, slug) {
+    return `${activeWorkTopicPrefix(change)}/${segment}/${normalizeTopicPart(slug)}`;
+}
+export function parseActiveWorkTopicKey(topicKey) {
+    const parts = topicKey?.split('/') ?? [];
+    if (parts[0] !== activeWorkTopicRoot || parts.length < 3)
+        return undefined;
+    const segment = parts[2];
+    if (!isActiveWorkSegment(segment))
+        return undefined;
+    if (isActiveWorkCurrentSegment(segment) && parts.length === 3)
+        return { change: parts[1], segment };
+    if (isActiveWorkDetailSegment(segment) && parts.length >= 4)
+        return { change: parts[1], segment, slug: parts.slice(3).join('/') };
+    return undefined;
+}
+function isActiveWorkSegment(value) {
+    return isActiveWorkCurrentSegment(value) || isActiveWorkDetailSegment(value);
+}
+function isActiveWorkCurrentSegment(value) {
+    return activeWorkCurrentSegments.includes(value);
+}
+function isActiveWorkDetailSegment(value) {
+    return activeWorkDetailSegments.includes(value);
+}
+function normalizeTopicPart(value) {
+    const trimmed = value.trim();
+    if (trimmed.length === 0 || trimmed.includes('/'))
+        throw new Error('Active-work topic parts must be non-empty path-safe values');
+    return trimmed;
+}

package/dist/setup/providers/opencode-setup-adapter.js

@@ -61,8 +61,8 @@ export const openCodeSetupAdapter = {
             writesProviderConfig: false,
             summary: contract.status === 'would_install'
                 ? contract.overwriteVgxness
-                    ? `OpenCode ${contract.action} reinstall plan is available for user-global provider configuration; confirmed apply overwrites VGXNESS entries only, preserves unrelated config, sets top-level permission.bash=ask and manager bash=allow, and creates managed backups for existing user-global targets.`
-                    : `OpenCode ${contract.action} plan is available for user-global provider configuration; confirmed applies mcp.vgxness, top-level permission.bash=ask, and manager bash=allow, and creates managed VGXNESS backups when merging. Project-local provider files are external/manual diagnostics and will not be modified.`
+                    ? `OpenCode ${contract.action} reinstall plan is available for user-global provider configuration; confirmed apply overwrites VGXNESS entries only, preserves unrelated config, sets top-level permission.bash=ask and manager bash=deny, and creates managed backups for existing user-global targets.`
+                    : `OpenCode ${contract.action} plan is available for user-global provider configuration; confirmed applies mcp.vgxness, top-level permission.bash=ask, and manager bash=deny, and creates managed VGXNESS backups when merging. Project-local provider files are external/manual diagnostics and will not be modified.`
                 : contract.message,
             ...(targetPath !== undefined ? { targetPath } : {}),
             warnings: contract.warnings,
@@ -155,8 +155,8 @@ function overwriteInstallRisks(installsAgents) {
     ];
 }
 function bashPermissionRisks(policy) {
-    return policy.manager === 'allow'
-        ? ['OpenCode top-level permission.bash is set to ask; terminal commands prompt by default, while vgxness-manager allows bash after restart.']
+    return policy.manager === 'deny'
+        ? ['OpenCode top-level permission.bash is set to ask; terminal commands prompt by default, while vgxness-manager denies bash after restart.']
         : ['OpenCode top-level permission.bash is set to ask.'];
 }
 function refusedRepairRisks(message) {

package/dist/setup/setup-plan.js

@@ -187,7 +187,7 @@ function setupPlanFromOpenCode(input) {
     };
 }
 function bashPermissionDescription(policy) {
-    return policy.manager === 'allow' ? '; sets top-level permission.bash to ask and manager bash to allow' : '; sets top-level permission.bash to ask';
+    return policy.manager === 'deny' ? '; sets top-level permission.bash to ask and manager bash to deny' : '; sets top-level permission.bash to ask';
 }
 function resolveSetupDatabase(input) {
     if (input.mode === 'global') {

package/dist/skills/skill-resolver.js

@@ -1,4 +1,5 @@
 import { resolveAgentSelector } from '../agents/agent-selector-resolver.js';
+import { canonicalDefaultAgentName } from '../agents/canonical-agent-manifest.js';
 import { normalizeSddPhaseInput } from '../sdd/schema.js';
 import { skillLookupContexts } from './personal-skills.js';
 export class SkillResolver {
@@ -109,14 +110,37 @@ export class SkillResolver {
                 return byId.ok ? ok({ agent: byId.value }) : byId;
             }
             const selected = resolveAgentSelector({ selector: input.agentId, project: input.project, scope: input.scope ?? 'project' }, { getById: (id) => this.agents.getById(id), getByName: (project, scope, name) => this.agents.getByName(project, scope, name) });
-            return selected.ok ? ok({ agent: selected.value.agent, ...(selected.value.warning !== undefined ? { warning: selected.value.warning } : {}) }) : selected;
+            if (selected.ok)
+                return ok({ agent: selected.value.agent, ...(selected.value.warning !== undefined ? { warning: selected.value.warning } : {}) });
+            if (selected.error.code !== 'not_found')
+                return selected;
+            const fallback = this.resolveAgentNameFallback(input);
+            if (fallback.ok && fallback.value.agent !== undefined) {
+                const warning = `AGENT_SELECTOR_PROVIDER_ALIAS_FALLBACK: selector "${input.agentId}" did not match a VGXNESS registry agent; resolved display/provider name to canonical agent "${fallback.value.agent.name}" (${fallback.value.agent.id}).`;
+                return ok({ agent: fallback.value.agent, warning });
+            }
+            return selected;
         }
         if (input.agentName === undefined)
             return ok({});
         if (input.project === undefined)
             return validationFailure('--project is required when resolving by agent name');
-        const byName = this.agents.getByName(input.project, input.scope ?? 'project', input.agentName);
-        return byName.ok ? ok({ agent: byName.value }) : byName;
+        return this.resolveAgentNameFallback(input);
+    }
+    resolveAgentNameFallback(input) {
+        if (input.project === undefined)
+            return validationFailure('--project is required when resolving by agent name');
+        for (const name of providerAgentNameCandidates(input.agentName, input.agentId)) {
+            const selected = resolveAgentSelector({ selector: name, project: input.project, scope: input.scope ?? 'project' }, { getById: (id) => this.agents.getById(id), getByName: (project, scope, agentName) => this.agents.getByName(project, scope, agentName) });
+            if (selected.ok)
+                return ok({ agent: selected.value.agent });
+            if (selected.error.code !== 'not_found')
+                return selected;
+        }
+        if (input.agentName === undefined)
+            return ok({});
+        const exact = this.agents.getByName(input.project, input.scope ?? 'project', input.agentName);
+        return exact.ok ? ok({ agent: exact.value }) : exact;
     }
     targetCandidates(input, agent) {
         const targets = [];
@@ -254,6 +278,32 @@ function isSddWorkflow(workflow) {
 function normalizedIntentSignals(signals) {
     return [...new Set((signals ?? []).map((signal) => signal.trim().toLowerCase()).filter(Boolean))];
 }
+function providerAgentNameCandidates(agentName, agentId) {
+    const candidates = [];
+    const add = (value) => {
+        const normalized = value?.trim();
+        if (normalized === undefined || normalized.length === 0 || candidates.includes(normalized))
+            return;
+        candidates.push(normalized);
+    };
+    add(agentName);
+    add(slugAgentDisplayName(agentName));
+    if (isProviderManagerAlias(agentId) || isProviderManagerAlias(agentName))
+        add(canonicalDefaultAgentName);
+    return candidates;
+}
+function slugAgentDisplayName(value) {
+    const normalized = value
+        ?.trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    return normalized === undefined || normalized.length === 0 ? undefined : normalized;
+}
+function isProviderManagerAlias(value) {
+    const normalized = slugAgentDisplayName(value);
+    return normalized === 'main-manager' || normalized === 'vgxness-manager' || normalized === 'vgxness-main-manager';
+}
 function stringMetadata(value) {
     return typeof value === 'string' && value.trim() ? value : undefined;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vgxness",
-  "version": "1.18.0",
+  "version": "1.19.0",
   "description": "CLI and MCP control plane for guided AI-agent workflows, SDD, memory, and OpenCode setup.",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {