vgxness 1.20.14 → 1.21.0

package/dist/application/knowledge-workspace/obsidian-mcp-workspace-port.js

@@ -0,0 +1,109 @@
+import { assertSafeWorkspaceRelativePath, isGeneratedByVgxness, } from './workspace-port.js';
+export class ObsidianMcpWorkspacePort {
+    options;
+    workspaceRoot;
+    constructor(options) {
+        this.options = options;
+        this.workspaceRoot = options.workspaceRoot ?? 'VGXNESS';
+    }
+    async status() {
+        try {
+            await this.options.client.callTool('obsidian_list_notes', { path: this.workspaceRoot, recursive: false });
+            return {
+                kind: 'knowledge-workspace-status',
+                status: 'available',
+                mode: 'obsidian-mcp',
+                workspaceRoot: this.workspaceRoot,
+                diagnostics: [],
+                safety: { readOnly: true, writesNotes: false, deletesNotes: false, executesObsidianCommands: false },
+            };
+        }
+        catch (cause) {
+            return {
+                kind: 'knowledge-workspace-status',
+                status: 'unavailable',
+                mode: 'obsidian-mcp',
+                workspaceRoot: this.workspaceRoot,
+                diagnostics: [`Obsidian MCP unavailable: ${cause instanceof Error ? cause.message : String(cause)}`],
+                safety: { readOnly: true, writesNotes: false, deletesNotes: false, executesObsidianCommands: false },
+            };
+        }
+    }
+    async listNotes(input) {
+        const path = assertSafeWorkspaceRelativePath(input.pathPrefix, this.workspaceRoot);
+        const result = await this.options.client.callTool('obsidian_list_notes', { path, recursive: input.recursive ?? true });
+        return extractNoteRefs(result);
+    }
+    async getNote(input) {
+        const path = assertSafeWorkspaceRelativePath(input.path, this.workspaceRoot);
+        const result = await this.options.client.callTool('obsidian_get_note', { path, format: 'content' });
+        return { path, content: extractContent(result) };
+    }
+    async writeGeneratedNote(input) {
+        const path = assertSafeWorkspaceRelativePath(input.path, this.workspaceRoot);
+        const existing = await this.readExisting(path);
+        if (existing !== undefined && input.overwriteGeneratedOnly && !isGeneratedByVgxness(existing.content)) {
+            throw new Error(`Refusing to overwrite non-generated Obsidian note: ${path}`);
+        }
+        const result = await this.options.client.callTool('obsidian_write_note', { path, content: input.content, overwrite: existing !== undefined });
+        return extractWriteResult(result, path, existing === undefined);
+    }
+    async patchNote(input) {
+        const path = assertSafeWorkspaceRelativePath(input.path, this.workspaceRoot);
+        const result = await this.options.client.callTool('obsidian_patch_note', {
+            path,
+            section: input.section,
+            operation: input.operation,
+            content: input.content,
+        });
+        return extractWriteResult(result, path, false);
+    }
+    async openInUi(input) {
+        const path = assertSafeWorkspaceRelativePath(input.path, this.workspaceRoot);
+        await this.options.client.callTool('obsidian_open_in_ui', { path, failIfMissing: true });
+    }
+    async readExisting(path) {
+        try {
+            return await this.getNote({ path });
+        }
+        catch {
+            return undefined;
+        }
+    }
+}
+function extractContent(result) {
+    if (typeof result === 'string')
+        return result;
+    if (isRecord(result)) {
+        if (typeof result.content === 'string')
+            return result.content;
+        if (typeof result.result === 'string')
+            return result.result;
+        const note = result.note;
+        if (isRecord(note) && typeof note.content === 'string')
+            return note.content;
+    }
+    return JSON.stringify(result);
+}
+function extractNoteRefs(result) {
+    const entries = isRecord(result) && Array.isArray(result.entries) ? result.entries : Array.isArray(result) ? result : [];
+    return entries.flatMap((entry) => {
+        if (!isRecord(entry) || typeof entry.path !== 'string')
+            return [];
+        const type = entry.type === 'directory' ? 'directory' : 'file';
+        return [{ path: entry.path, type }];
+    });
+}
+function extractWriteResult(result, path, defaultCreated) {
+    if (!isRecord(result))
+        return { path, created: defaultCreated };
+    const output = { path, created: typeof result.created === 'boolean' ? result.created : defaultCreated };
+    if (typeof result.previousSizeInBytes === 'number')
+        output.previousSizeInBytes = result.previousSizeInBytes;
+    if (typeof result.currentSizeInBytes === 'number')
+        output.currentSizeInBytes = result.currentSizeInBytes;
+    return output;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}

package/dist/application/knowledge-workspace/workspace-port.js

@@ -0,0 +1,20 @@
+export function assertSafeWorkspaceRelativePath(path, workspaceRoot = 'VGXNESS') {
+    const normalized = normalizeWorkspacePath(path);
+    const normalizedRoot = normalizeWorkspacePath(workspaceRoot);
+    if (normalizedRoot === '' || normalizedRoot === '.' || normalizedRoot.includes('..'))
+        throw new Error('Invalid workspace root');
+    if (normalized !== normalizedRoot && !normalized.startsWith(`${normalizedRoot}/`)) {
+        throw new Error(`Path must stay under ${normalizedRoot}/: ${path}`);
+    }
+    return normalized;
+}
+export function isGeneratedByVgxness(content) {
+    return /^---[\s\S]*?^generated_by:\s*vgxness\s*$/m.test(content);
+}
+export function normalizeWorkspacePath(path) {
+    const normalized = path.replace(/\\/g, '/').replace(/^\/+/, '').replace(/\/+/g, '/').trim();
+    const parts = normalized.split('/').filter((part) => part.length > 0 && part !== '.');
+    if (parts.some((part) => part === '..'))
+        throw new Error(`Path traversal is not allowed: ${path}`);
+    return parts.join('/');
+}

package/dist/application/memory/import/observation-writer.js

@@ -1,5 +1,5 @@
-import { sddTopicKey } from '../../../sdd/schema.js';
-import { SddWorkflowService } from '../../../sdd/sdd-workflow-service.js';
+import { sddTopicKey } from '../../../domain/sdd/schema.js';
+import { SddWorkflowService } from '../../sdd/sdd-workflow-service.js';
 import { validateMemoryImportPackage, } from './package.js';
 const context = { actor: 'memory-import' };
 export function writeMemoryImportObservations(input) {

package/dist/application/memory/import/package.js

@@ -1,4 +1,4 @@
-import { isSddPhase, sddPhases, sddTopicKey } from '../../../sdd/schema.js';
+import { isSddPhase, sddPhases, sddTopicKey } from '../../../domain/sdd/schema.js';
 export const MEMORY_IMPORT_PACKAGE_KIND = 'vgxness.memory-import-package';
 export const MEMORY_IMPORT_PACKAGE_VERSION = 1;
 export const MEMORY_IMPORT_PACKAGE_SOURCE = 'engram';

package/dist/application/provider-setup/provider-change-plan.js

@@ -1,6 +1,6 @@
 import { planClaudeCodeMcpInstall, } from '../../adapters/claude/install/client-install-claude-code-contract.js';
 import { planOpenCodeMcpInstall } from '../../adapters/opencode/install/client-install-opencode-contract.js';
-import { resolveMemoryDatabasePath } from '../../memory/storage-paths.js';
+import { resolveMemoryDatabasePath } from '../../storage/memory/storage-paths.js';
 import { ProviderDoctorService } from './provider-doctor.js';
 import { providerRuntimeContext, } from './provider-health-types.js';
 import { ProviderStatusService } from './provider-status.js';

package/dist/application/provider-setup/provider-doctor.js

@@ -470,7 +470,7 @@ function delegationCheck(config) {
     const missing = vgxnessOpenCodeSddSubagents.filter((name) => permission[name] !== 'allow');
     if (missing.length > 0)
         return { id: 'opencode-delegation-permissions', status: 'fail', detail: `Manager cannot delegate to expected subagents: ${missing.join(', ')}.` };
-    return { id: 'opencode-delegation-permissions', status: 'pass', detail: 'Manager task permission is deny-by-default and allows exact capability subagents plus legacy SDD aliases.' };
+    return { id: 'opencode-delegation-permissions', status: 'pass', detail: 'Manager task permission is deny-by-default and allows exact canonical capability subagents only.' };
 }
 function promptContractCheck(config, expected) {
     const agents = isRecord(config?.agent) ? config.agent : undefined;

package/dist/application/runs/run-service.js

@@ -1,7 +1,7 @@
 import { createHash } from 'node:crypto';
 import { evaluatePermission } from '../../permissions/policy-evaluator.js';
 import { isRiskyPermissionCategory } from '../../permissions/schema.js';
-import { normalizeSddPhaseInput } from '../../sdd/schema.js';
+import { normalizeSddPhaseInput } from '../../domain/sdd/schema.js';
 import { RunRepository, } from '../../storage/runs/repositories/runs.js';
 import { AllowlistedApplyProgressCommandExecutor } from '../../workflows/command-allowlist-adapter.js';
 import { planExecutionIsolation, recommendWorkspaceStrategyForExecution } from './execution-planning.js';

package/dist/application/sdd/sdd-continuation-plan.js

@@ -27,7 +27,8 @@ export function sddContinuationPlanFrom(input) {
         safety: [
             'Read-only planner: this command does not execute providers or mutate SDD artifacts, runs, provider config, or openspec/ files.',
             'Human acceptance remains explicit; artifact presence is not treated as acceptance.',
-            'Continue SDD phases in OpenCode conversation through VGXNESS MCP and reusable capability subagents; the removed code runtime is not a CLI fallback.',
+            'OpenCode and Claude execute provider-native; VGXNESS MCP and SQLite govern SDD artifacts, memory, permissions, runs, and evidence.',
+            'Continue SDD phases in OpenCode or Claude, using capability subagents when helpful; the removed code runtime is not a CLI fallback.',
             'No openspec/ files are created or written.',
         ],
     };
@@ -115,7 +116,7 @@ function draftPhaseAction(project, change, phase, reason) {
         id: `sdd.${change}.${phase}.draft`,
         label: `Prepare ${phase} draft through normal SDD phase flow`,
         title: `Prepare ${phase} draft`,
-        description: 'The next SDD phase appears runnable; draft generation must still use the normal phase workflow and any required preflight gates. After a valid phase artifact is produced, save it as a draft immediately, then ask the human acceptance/continue question before advancing.',
+        description: 'The next SDD phase appears runnable; draft generation still happens in provider-native OpenCode or Claude through normal phase workflow and any required preflight gates. After a valid phase artifact is produced, save it as a draft immediately, then ask the human acceptance/continue question before advancing.',
         kind: 'draft-phase',
         category: 'sdd-phase',
         phase,
@@ -130,7 +131,7 @@ function draftPhaseAction(project, change, phase, reason) {
         requiresPreflight: true,
         requiresProviderWriteConsent: false,
         reason,
-        rationale: 'This continuation tool is read-only, so it can recommend the next phase but cannot execute providers or save artifacts itself.',
+        rationale: 'This continuation tool is read-only, so it can recommend the next phase but cannot execute providers, require subagents, or save artifacts itself.',
         blockingPrerequisites: [],
     };
 }

package/dist/application/skills/skill-registry-service.js

@@ -1,4 +1,4 @@
-import { AgentRepository } from '../../agents/repositories/agents.js';
+import { AgentRepository } from '../../storage/agents/repositories/agents.js';
 import { SkillEvaluationRequestRepository, } from '../../storage/skills/repositories/skill-evaluation-requests.js';
 import { SkillEvaluationScenarioRepository, } from '../../storage/skills/repositories/skill-evaluation-scenarios.js';
 import { SkillImprovementProposalRepository, } from '../../storage/skills/repositories/skill-improvement-proposals.js';

package/dist/application/skills/skill-resolver.js

@@ -1,6 +1,6 @@
-import { resolveAgentSelector } from '../../agents/agent-selector-resolver.js';
-import { canonicalDefaultAgentName } from '../../agents/canonical-agent-manifest.js';
-import { normalizeSddPhaseInput } from '../../sdd/schema.js';
+import { resolveAgentSelector } from '../agents/agent-selector-resolver.js';
+import { canonicalDefaultAgentName } from '../../domain/agents/canonical-agent-manifest.js';
+import { normalizeSddPhaseInput } from '../../domain/sdd/schema.js';
 import { skillLookupContexts } from './personal-skills.js';
 export class SkillResolver {
     skills;

package/dist/cli/bun-bin.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 import { writeFileSync } from 'node:fs';
 import { basename } from 'node:path';
-import { canonicalDefaultAgentName, canonicalPromptContractVersion, canonicalSddSubagentNames } from '../agents/canonical-agent-manifest.js';
+import { canonicalDefaultAgentName, canonicalPromptContractVersion, canonicalSddSubagentNames } from '../domain/agents/canonical-agent-manifest.js';
 writeRuntimeEvidence();
 await import('./index.js');
 function writeRuntimeEvidence() {

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

@@ -2,7 +2,7 @@ import { canonicalBehaviorContractVersion } from '../../behavior/behavior-contra
 export const canonicalDefaultAgentName = 'vgxness-manager';
 export const canonicalOpenCodeDefaultModel = 'openai/gpt-5.5';
 export const canonicalOpenCodeManagerReasoningEffort = 'high';
-export const canonicalPromptContractVersion = 26;
+export const canonicalPromptContractVersion = 27;
 export const canonicalCapabilitySubagentNames = [
     'vgxness-explore',
     'vgxness-propose',
@@ -144,7 +144,6 @@ export function createCanonicalOpenCodeSddTaskPermissions() {
     return Object.fromEntries([
         ['*', 'deny'],
         ...canonicalCapabilitySubagentNames.map((name) => [name, 'allow']),
-        ...Object.keys(canonicalCapabilitySubagentLegacyAliases).map((name) => [name, 'allow']),
     ]);
 }
 export function createCanonicalOpenCodeSddMcpToolPermissions() {
@@ -217,14 +216,14 @@ Bind to \`vgxness-manager\`.
 Coordinate VGXNESS work without forcing every request through SDD. Keep chat thin, use MCP state, and delegate only when the task needs a reusable capability subagent or focused executor. Coach briefly: explain tradeoffs/risks, challenge weak assumptions, keep user in control, avoid lectures. Verify before agreeing with technical claims. When blocked, ask one focused question.
 
 ## Instruction layering
-This prompt is the VGXNESS operating contract; OpenCode also appends environment, global/project AGENTS.md, MCP instructions, skills, and user instructions. Treat those as active instructions. Prefer direct user intent and repo/global instructions for style/scope; prefer this contract for VGXNESS routing, SDD governance, and MCP usage. If layers conflict, preserve user work and ask only when ambiguity changes the action.
+This is the VGXNESS operating contract; OpenCode also appends environment, global/project AGENTS.md, MCP instructions, skills, and user instructions. Treat them as active. Prefer user intent and repo/global style; prefer this contract for VGXNESS routing, SDD governance, and MCP usage. If layers conflict, preserve user work and ask only when ambiguity changes the action.
 
 ## Non-negotiable governance
 - VGXNESS uses SQLite artifacts/control-plane; OpenCode as primary provider; artifacts are not openspec files. Do not write to \`openspec/\`.
 - 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. If the user asks for a concrete action (run tests, commit, push, publish, reinstall config), treat it as authorization for that exact operation: pass structured \`explicitRequest\` with human actor, timestamp/source, exact category/operation/scope/risk/parser evidence. If the user says "hazlo"/"dale" immediately after you listed concrete operations, bind it to those operations with \`parser.exact: true\` and no expansion reasons. If preflight allows \`authorizationMode: "explicit-request"\`, execute without duplicate confirmation. Stop only on approval-needed, blocked, ambiguity, secrets, destructive/privileged scope not explicitly named, or provider/global config mutation not exactly requested; never invent approval.
-- 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.
+- 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. If the user asks for a concrete action, pass structured \`explicitRequest\` with human actor, timestamp/source, exact category/operation/scope/risk/parser evidence. If the user says "hazlo"/"dale" immediately after you listed concrete operations, bind it to those operations with \`parser.exact: true\` and no expansion reasons. If preflight allows \`authorizationMode: "explicit-request"\`, execute without duplicate confirmation. Stop on approval-needed, blocked, ambiguity, secrets, destructive/privileged scope not named, or provider/global config mutation not exactly requested; never invent approval.
+- 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 exact proposal acceptance or trusted draft autorun after proposal acceptance; excludes edits, shell/tests, git, provider config, memory writes, external paths, secrets, destructive/privileged/ambiguous operations.
 - OpenCode native bash/edit/write stay denied to the manager; use MCP preflight and delegated executors for side effects. Diagnostics are config-level evidence, not host proof.
 - Do not mutate provider/global OpenCode config or publish unless explicitly requested. Never overwrite unrelated work. Preserve \`permission.task\` deny-by-default with exact known capability subagents only.
 - Do not change provider model/reasoning config unless explicitly requested.
@@ -234,7 +233,8 @@ Use the lightest safe path; do not force SDD/subagents for small direct work. T0
 Do not invent or invoke generic reviewer subagents; use exact canonical capability subagents only when the task benefits from focused execution. These capability subagents can support direct work, planning, research, verification, or formal SDD phases. Only treat their output as SDD artifacts when the route is formal SDD and governance persistence/readiness applies.
 
 ## Parallel delegation
-When work has independent analysis, verification, research, codebase investigation, debugging, code review, SDD drafting/review, or context-dependent implementation streams, create a bounded parallel batch instead of serializing by habit. Default max concurrency is 3 subagents; honor configured lower/higher limits only within validated safety caps. Launch only exact allowlisted capability subagents/roles, never wildcard or unknown agents, and never allow recursive delegation. Stay serial when tasks depend on each other, scope is unclear, the result of one task chooses the next task, or the cost/noise exceeds the benefit. For implementation fan-out, require independent paths/scopes plus preflight/human gates for risky mutations, destructive actions, publish, merge, provider config, privileged scope, secrets, or external roots. Each launched subagent gets bounded instructions: task, workspace, allowed tools, expected evidence, no recursive delegation, and concise result envelope. Before reporting completion, synthesize every result with evidence, conflicts, failures/timeouts, residual risk, and the chosen next serial action.
+Gentle-compatible VGXNESS patterns: Context-cost delegation matrix: direct work for small, clear, low-context requests; delegate broad, specialized, parallelizable, context-heavy, execution-heavy, or independent-review work. Do not delegate all real work. Launch deduplication: keep a session log by capability, task fingerprint, and artifact refs. Phase gatekeeper checks after delegated/draft phases: validate result envelope, SQLite artifact existence/readability, scope alignment, evidence-backed claims, readiness coherence, and unresolved critical risks. Skill-resolution feedback: call vgxness_skill_payload for non-trivial work and inspect returned skill_resolution. Review workload guard: estimate reviewer load, split/chains above budget, and stop for size-exception decisions. Every subagent task must include bounded role, exact task, artifact/memory context, constraints, side-effect boundary, expected output/evidence, focused verification, and no recursive delegation.
+When work has independent analysis, verification, research, codebase investigation, debugging, code review, SDD drafting/review, or context-dependent implementation streams, create a bounded parallel batch. Default max concurrency is 3 subagents within validated caps. Launch only exact allowlisted capability subagents/roles; never wildcard/unknown agents and never allow recursive delegation. Stay serial when tasks depend, scope is unclear, one result chooses the next step, or cost/noise exceeds benefit. For implementation fan-out, require independent paths/scopes plus preflight/human gates for risky mutations, destructive actions, publish, merge, provider config, privileged scope, secrets, or external roots. Give each subagent bounded instructions and before completion synthesize every result with evidence, conflicts, failures/timeouts, residual risk, and the chosen next serial action.
 
 ## Provider-native daily flow
 SDD happens in OpenCode conversation + VGXNESS MCP/subagents. No terminal SDD phase commands. CLI is an escape hatch for bootstrap, doctor, recovery, setup gaps, or explicit request.
@@ -244,19 +244,19 @@ SDD happens in OpenCode conversation + VGXNESS MCP/subagents. No terminal SDD ph
 - Bounded resume/start hard stop: for generic "continue"/"sigamos"/"continuemos"/"resume development" without an explicit change, call \`vgxness_resume_context\` before any SDD continuation/status. \`proceed-explicit-change\` or \`proceed-single-active-work\` may continue with that change; \`inspect-interrupted-run\` means inspect it. On \`ask-change\`: do not call \`vgxness_agent_resolve\`; do not call SDD continuation/status, do not create runs, do not inspect repo files/native repo tools, do not use Glob/Read/docs, do not delegate to capability subagents, do not start runs or use skill fallback; ask one question: "¿qué cambio retomamos?".
 - Project preparation: to start a new project/product/app or idea, clarify goals, users, scope, constraints, stack, repo/location, integrations, data, security, deliverables, milestones, success criteria and propose PRD/requirements/design/tasks/roadmap. If the UI/provider supports selectable options, present 2-4 clear options; ask only path-changing decisions.
 - Proposal clarity: if product/business clarity is missing, run a proposal question round.
-- SDD artifacts: guide with \`vgxness_sdd_next\`/\`vgxness_sdd_cockpit\`; bodies use memory-style API \`vgxness_memory_get\`/\`vgxness_memory_save\`/\`vgxness_memory_update\` + \`kind: "sdd-artifact"\`. Legacy aliases: \`vgxness_sdd_get_artifact\`/\`vgxness_sdd_list_artifacts\`/\`vgxness_sdd_save_artifact\`. Summarize proposal draft then ask accept+continue. After proposal acceptance, organically draft spec -> design -> tasks without separate confirmations; summarize plan and ask to start apply. Use \`vgxness_sdd_reopen_artifact\` for rejected artifacts only, with human actor/audit context.
+- SDD artifacts: guide with \`vgxness_sdd_next\`/\`vgxness_sdd_cockpit\`; bodies use memory-style API \`vgxness_memory_get\`/\`vgxness_memory_save\`/\`vgxness_memory_update\` + \`kind: "sdd-artifact"\`. Legacy aliases: \`vgxness_sdd_get_artifact\`/\`vgxness_sdd_list_artifacts\`/\`vgxness_sdd_save_artifact\`. Summarize proposal draft as the first mandatory human gate, then ask accept+continue. After proposal acceptance, organically draft spec -> design -> tasks as unaccepted drafts without separate confirmations; summarize the package and ask to start apply. Use \`vgxness_sdd_reopen_artifact\` for rejected artifacts only, with human actor/audit context.
 - delegated capability subagent outputs: inspect delegated result-envelope completeness before SDD artifact persistence or phase advancement (status, executive_summary, artifacts_examined, skill_resolution, risks, next_recommended); this is prompt guidance only, not runtime parsing/rejection.
-- Organic SDD flow: proposal is the first human gate. After acceptance, run \`spec -> design -> tasks\` as draft autorun without extra confirmations; save drafts with \`vgxness_memory_save\` + \`kind: "sdd-artifact"\`, summarize the package, then ask one focused apply-start confirmation. After apply, verify with allowed/focused checks or ask if risky; after verify, summarize evidence and ask archive confirmation. This is automation, not silent acceptance/completion; re-check status/readiness.
-- Acceptance/readiness: check exact status/readiness; call \`vgxness_sdd_accept_artifact\` directly with audit context; re-check before reporting. Do not preflight solely for exact acceptance. Affirmative continue/sí/yes/dale to the immediate accept+continue prompt is explicit human acceptance; only save/no/revise keeps draft and must not advance. Never silently auto-accept. Use \`vgxness_governance_report\` for audit.
+- Organic SDD flow: proposal is the first mandatory human gate. After proposal acceptance, run \`spec -> design -> tasks\` as draft autorun without extra confirmations; save drafts with \`vgxness_memory_save\` + \`kind: "sdd-artifact"\`, summarize the package, then ask one focused apply-start confirmation. After apply, verify with allowed/focused checks or ask if risky; after verify, summarize evidence and ask archive confirmation when archive means official completion. This is automation, not silent acceptance/completion; re-check status/readiness.
+- Acceptance/readiness: check exact status/readiness; call \`vgxness_sdd_accept_artifact\` directly with audit context; re-check before reporting. Do not preflight solely for exact acceptance. Affirmative continue/sí/yes/dale to the immediate proposal accept+continue prompt is explicit human proposal acceptance; only save/no/revise keeps draft and must not advance. Spec/design/tasks drafts do not need ceremonial per-artifact acceptance before apply-start confirmation. Never silently auto-accept. Use \`vgxness_governance_report\` for audit.
 - Context memory lifecycle: use memory for both SDD and non-SDD work. At start/resume, before choosing a route for non-trivial work, and before changing architecture/config/workflows, search/get relevant memories to avoid losing prior context. During work, use memory as advisory context only. At natural checkpoints/end, save or update durable lessons/decisions/preferences so future sessions start informed.
-- Memory write policy: proactively save/update durable decisions, architecture choices, reusable project conventions, workflow preferences, active-work summaries, and non-obvious gotchas. Save/update only durable, actionable, scoped, evidence-backed, compact, non-sensitive observations. Prefer \`vgxness_memory_update\` over duplicate save when you know the id/topic key; otherwise use \`vgxness_memory_save\`. Ordinary qualifying memory writes are agent-decided and audit-only; they do not require extra confirmation or preflight. Treat lifecycle \`memoryCapture\` as review-first advisory metadata only: no automatic persistence, no durable queue. Do not save full SDD artifacts, transcripts, raw logs, hidden reasoning, secrets, credentials, or sensitive user data. Memory is advisory only and never proves SDD acceptance/readiness/verification/approval/authorization. SDD artifacts are canonical for phase deliverables and governance state. OpenCode previews/handoff are read-only and capture-free. Choose scope intentionally: \`project\` for repo facts, \`personal\` for reusable user preferences. Ask before memory writes only for sensitive, ambiguous, or user-personal content beyond stated preferences.
+- Memory write policy: proactively save/update durable decisions, architecture choices, reusable project conventions, workflow preferences, active-work summaries, and non-obvious gotchas. Save only durable, actionable, scoped, evidence-backed, compact, non-sensitive observations. Prefer \`vgxness_memory_update\` over duplicate save when you know the id/topic key; otherwise use \`vgxness_memory_save\`. Ordinary qualifying memory writes are agent-decided and audit-only; they do not require extra confirmation or preflight. Treat lifecycle \`memoryCapture\` as review-first advisory metadata only: no automatic persistence, no durable queue. Do not save full SDD artifacts, transcripts, raw logs, hidden reasoning, secrets, credentials, or sensitive user data. Memory is advisory only and never proves SDD acceptance/readiness/verification/approval/authorization. SDD artifacts are canonical for phase deliverables and governance state. OpenCode previews/handoff are read-only and capture-free. Choose scope intentionally: \`project\` for repo facts, \`personal\` for reusable user preferences. Ask only for sensitive, ambiguous, or user-personal content beyond stated preferences.
 - 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, approval, 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\` (include \`explicitRequest\` only for exact human-requested one-off actions), 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[]\`. Explicit request never proves SDD acceptance and never authorizes provider/global config mutation unless the human request names that exact config scope.
 - Provider diagnostics: \`vgxness_provider_status\`/\`vgxness_provider_doctor\` read-only; report evidence limits; use status for configured/phase/next and doctor for OpenCode MCP/manager health. Code context: \`vgxness_code_context_status\` only. code-context status evidence is advisory and read-only; queries CLI-only pending grants. Do not install/initialize CodeGraph/Graphify, write provider config, or treat evidence as SDD acceptance/verification.
 
 ## Minimum flows
-- Organic SDD: propose -> save draft -> ask accept+continue. Once accepted, automatically draft spec -> design -> tasks, summarize plan, then ask to start apply. After apply, run/request verify, then ask to archive after evidence is summarized. Drafts stay unaccepted until human acceptance; never silently accept.
+- Organic SDD: propose -> save draft -> ask accept+continue as the first mandatory human gate. Once the proposal is accepted, automatically draft spec -> design -> tasks as unaccepted drafts, summarize the plan package, then ask to start apply. After apply, run/request verify, then ask to archive after evidence is summarized when archive is official completion. Drafts stay unaccepted until human acceptance; never silently accept or ask for ceremonial per-artifact acceptance.
 - Direct change: for small explicit edits, local fixes, docs tweaks, focused tests, config reads, or narrow commands, inspect minimal context -> change directly -> run narrow verification -> summarize. Use preflight/\`explicitRequest\` for risky operations, but do not start SDD or delegate unless scope grows.
 - New project preparation: clarify idea -> capture decisions -> propose docs/control artifacts -> choose single PR vs stacked plan -> then implement. Do not code before required inputs are known unless the user explicitly asks for a spike/prototype.
 - Git/PR hygiene: never implement on main. Sync main, create a topic branch/worktree before edits, preserve unrelated work, use conventional commits, link an approved issue when repo policy requires it, and include verification evidence in PRs. Estimate changed lines before PR: <=400 focused lines can be one PR; >400 lines or multiple review units should become stacked/chained PRs, or ask the user to choose single PR with size exception vs stacked plan.
@@ -277,10 +277,10 @@ Be concise.`;
  */
 const registryManagerInstructionsV11 = [
     'You are the VGXNESS manager/coordinator, not a monolithic executor and not an SDD-only bot. 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. Always verify before agreeing with technical claims; when blocked, ask one focused question and stop.',
-    'Default to direct inline execution for small concrete user requests, narrow edits, single-file fixes, docs updates, simple commands, and focused verification. When a user starts a new project/product/app or brings an undeveloped idea, run a preparation phase first: clarify goals, users, scope, constraints, stack, repo/location, integrations, data, security, deliverables, milestones, success criteria, and desired PRD/requirements/design/tasks/roadmap artifacts; offer 2-4 options when provider UI supports choices. Delegate only when scope is SDD phase-shaped, broad repository exploration, complex implementation, incident recovery, multi-step analysis, or independent workstreams that benefit from parallel subagents. When the task can split into independent analysis, verification, research, debugging, code review, SDD drafting/review, or context-dependent implementation streams, plan a bounded parallel batch with default max concurrency 3 and configurable validated caps. Launch exact allowlisted subagents only; never wildcard, unknown agents, or recursive delegation. Keep implementation fan-out gated by independent paths/scopes plus preflight/human approval for risky mutations, destructive actions, publish, merge, provider config, privileged scope, secrets, or external roots. Synthesize all subagent results with evidence, conflicts, failures, residual risk, and next action before reporting completion. When uncertain, narrow scope first; use exact capability subagents only if the work is genuinely phase-shaped. do not invent or invoke generic reviewer subagents; use exact canonical capability subagents or MCP guidance only.',
+    'Default to direct inline execution for small concrete user requests, narrow edits, single-file fixes, docs updates, simple commands, and focused verification. Context-cost delegation matrix: direct work for small, clear, low-context requests; delegate broad, specialized, parallelizable, context-heavy, execution-heavy, or independent-review work. Do not delegate all real work. Every subagent task must include bounded role, exact task, artifact/memory context, constraints, side-effect boundary, expected output/evidence, focused verification, and no recursive delegation. When a user starts a new project/product/app or brings an undeveloped idea, run a preparation phase first: clarify goals, users, scope, constraints, stack, repo/location, integrations, data, security, deliverables, milestones, success criteria, and desired PRD/requirements/design/tasks/roadmap artifacts; offer 2-4 options when provider UI supports choices. Delegate only when scope is SDD phase-shaped, broad repository exploration, complex implementation, incident recovery, multi-step analysis, or independent workstreams that benefit from parallel subagents. When the task can split into independent analysis, verification, research, debugging, code review, SDD drafting/review, or context-dependent implementation streams, plan a bounded parallel batch with default max concurrency 3 and configurable validated caps. Launch deduplication: keep a session log by capability, task fingerprint, and artifact refs before launching another subagent. Launch exact allowlisted subagents only; never wildcard, unknown agents, or recursive delegation. Keep implementation fan-out gated by independent paths/scopes plus preflight/human approval for risky mutations, destructive actions, publish, merge, provider config, privileged scope, secrets, or external roots. Phase gatekeeper checks after delegated/draft phases: validate result envelope, SQLite artifact existence/readability, scope alignment, evidence-backed claims, readiness coherence, and unresolved critical risks. Skill-resolution feedback: use vgxness_skill_payload for non-trivial work and inspect returned skill_resolution. Review workload guard: estimate reviewer load, split/chains above budget, and stop for size-exception decisions. Synthesize all subagent results with evidence, conflicts, failures, residual risk, and next action before reporting completion. When uncertain, narrow scope first; use exact capability subagents only if the work is genuinely phase-shaped. do not invent or invoke generic reviewer subagents; use exact canonical capability subagents or MCP guidance only.',
     'Use VGXNESS MCP as the durable control plane: for generic resume/continue prompts call vgxness_resume_context first, pass explicitChange only when the user gave an exact valid change, and do not infer a change from context_cockpit.memoryPreviews; for retrospective/status prompts such as "what did we do?" or "qué habíamos hecho", inspect recent completed run history first with vgxness_run_list completed and mention interrupted candidates only as old blockers, not as latest truth; vgxness_context_cockpit and vgxness_session_restore are advisory context only after the gate, and context cockpit previews, memoryPreviews, and SDD summaries are advisory only. Close/pause/compact with vgxness_session_close using actor manager plus an actionable summary when a current session id exists.',
     'For generic continue/sigamos/continuemos/resume development without an explicit user change, call vgxness_resume_context before any SDD status/continuation. If decision is proceed-explicit-change or proceed-single-active-work, then call SDD tools for that change. If inspect-interrupted-run, call vgxness_run_resume_inspect. If ask-change (no interrupted run, no exact user-specified change, and no single parsed active-work change), hard stop: do not call vgxness_agent_resolve; do not call vgxness_sdd_status or vgxness_sdd_continue, do not create runs, do not inspect repo files/native repo tools, do not delegate to capability subagents, do not start runs, do not use skill_index/skill_search fallback, or invent agent ids; ask one question: "¿qué cambio retomamos?".',
-    'Manager save-then-accept behavior: after a valid hidden phase subagent artifact, save it immediately as a draft with sdd_save_artifact, summarize the saved draft, then ask whether the human accepts it and wants to continue to the next phase. An affirmative continue/sí/yes/dale reply in that immediate context is explicit human acceptance. A reply of only save/no/revise keeps draft and must not advance. Never silently auto-accept.',
+    'Organic proposal-gate behavior: after a valid proposal artifact, save it immediately as a draft with sdd_save_artifact, summarize the proposal, then ask whether the human accepts the scope and wants to continue. An affirmative continue/sí/yes/dale reply in that immediate proposal-gate context is explicit human proposal acceptance. After proposal acceptance, spec/design/tasks run sequentially as draft-only autorun without separate confirmations or ceremonial per-artifact acceptance; summarize the package and ask one focused apply-start confirmation. A reply of only save/no/revise keeps draft and must not advance. Never silently auto-accept, never treat subagent output as acceptance, and keep provider/global config, git/publish, destructive, external, privileged, secrets, install, network, and official archive gates risk-based and explicit.',
     'Instruction layering: OpenCode appends environment, global/project AGENTS.md, MCP instructions, skills, and user instructions after the provider agent prompt; treat them as active context. Prefer direct user intent and repo/global instructions for style/scope, and this manager contract for VGXNESS routing, SDD governance, and MCP usage.',
     'Run preflight explicit-request behavior: when a human explicitly requests a concrete risky action, pass structured explicitRequest to vgxness_run_preflight with human actor, request source/timestamp, exact category/operation/scope, risk flags, and parser exactness. If the user says "hazlo"/"dale" immediately after concrete operations were listed, bind it to those listed operations with parser.exact true and no expansion reasons. If preflight returns allowed with authorizationMode explicit-request, execute without duplicate confirmation. Ask/wait only for approval-needed, ambiguity, secrets, destructive/privileged scope not explicitly named, or provider/global config mutation not exactly requested. Never use explicitRequest to infer SDD acceptance.',
     '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; inspect delegated result-envelope completeness before SDD artifact persistence or phase advancement (status, executive_summary, artifacts_examined, skill_resolution, risks, next_recommended) as prompt guidance only, not runtime parsing/rejection; when proposal is accepted, spec/design/tasks run sequentially as draft-only autorun; then ask one focused apply-start confirmation and later archive confirmation while acceptance remains human-only. Context memory lifecycle: use memory in SDD and non-SDD work. Search/get relevant memories at start/resume, before routing non-trivial work, and before changing architecture/config/workflows; use matches as advisory context only. Save/update at checkpoints/end when work creates durable decisions, architecture choices, reusable conventions, workflow preferences, active-work summaries, or non-obvious gotchas. Memory write policy: ordinary qualifying writes are agent-decided and audit-only; they do not require extra confirmation or preflight; lifecycle memoryCapture candidates are review-first advisory metadata only, not persisted automatically, not a durable candidate queue, and still require explicit save/update policy; prefer update by known id/topicKey over duplicate saves; never save full SDD artifacts, transcripts, raw logs, hidden reasoning, secrets, credentials, or sensitive user data. Memory is advisory only and never proves SDD acceptance, readiness, verification, approval, or authorization. SDD artifacts are canonical for phase deliverables/governance state. OpenCode previews/handoff are read-only and capture-free. Choose project scope for repo-specific facts and personal scope for reusable user preferences; ask before memory writes only when content is sensitive, ambiguous, user-personal beyond stated preferences, or the user explicitly says not to persist it. Resolve exact capability 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.',

package/dist/domain/knowledge-workspace/schema.js

@@ -0,0 +1 @@
+export {};

package/dist/governance/governance-report-builder.js

@@ -1,5 +1,5 @@
 import { getSddPhasePermissionMatrixForPhase, permissionCategories, sddPhasePermissionMatrixVersion } from '../permissions/policy-evaluator.js';
-import { isSddPhase, normalizeSddArtifact, normalizeSddPhaseInput } from '../sdd/schema.js';
+import { isSddPhase, normalizeSddArtifact, normalizeSddPhaseInput } from '../domain/sdd/schema.js';
 import { fingerprintManagerProfileOverlay } from './overlay-fingerprint.js';
 export class GovernanceReportBuilder {
     services;

package/dist/interfaces/cli/bun-bin.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 import { writeFileSync } from 'node:fs';
 import { basename } from 'node:path';
-import { canonicalDefaultAgentName, canonicalPromptContractVersion, canonicalSddSubagentNames } from '../../agents/canonical-agent-manifest.js';
+import { canonicalDefaultAgentName, canonicalPromptContractVersion, canonicalSddSubagentNames } from '../../domain/agents/canonical-agent-manifest.js';
 writeRuntimeEvidence();
 await import('./index.js');
 function writeRuntimeEvidence() {

package/dist/interfaces/cli/cli-flags.js

@@ -1,6 +1,6 @@
-import { resolveMemoryDatabasePath } from '../../memory/storage-paths.js';
+import { resolveMemoryDatabasePath } from '../../storage/memory/storage-paths.js';
 import { permissionCategories } from '../../permissions/policy-evaluator.js';
-import { parseOperationRetryPolicy } from '../../runs/operation-retry.js';
+import { parseOperationRetryPolicy } from '../../application/runs/operation-retry.js';
 import { vgxnessSetupDefaults } from '../../setup/setup-defaults.js';
 import { validationFailure } from './cli-help.js';
 function parseArgs(argv) {

package/dist/interfaces/cli/cli-help.js

@@ -6,6 +6,8 @@ Global flags:
   --version, -v    Print the installed package version.
 
 Areas:
+  VGXNESS is a local-first governance OS/control plane for existing coding agents.
+  OpenCode and Claude execute provider-native; VGXNESS MCP and SQLite govern SDD artifacts, memory, permissions, runs, and evidence.
   status [--project <name>] [--change <id>] [--db <path>] [--json]
   next [--project <name>] [--change <id>] [--db <path>] [--json]
   resume [--project <name>] [--run-id <id>] [--db <path>] [--json]
@@ -20,6 +22,9 @@ Areas:
   verification plan --type docs-only|test-only|cli|mcp|sdd-storage|provider-setup|package-release|workflow-runs|code-context [--json]
   verification report save --project <name> --change <id> --file <report.json> [--db <path>] [--json]
   verification report get --project <name> --change <id> [--db <path>] [--json]
+  knowledge status [--workspace obsidian-mcp|filesystem] [--vault <path>] [--json]
+  knowledge init [--workspace obsidian-mcp|filesystem] [--vault <path>] [--json]
+  knowledge export --project <name> [--workspace obsidian-mcp|filesystem] [--vault <path>] [--kind docs|memory|sdd|canvas|all] [--limit <n>] [--db <path>]
   Status answers "where am I?" with the human front-door cockpit.
   Next answers "what should I do now?" with a shorter next-action view.
   Resume answers "how do I continue interrupted work?" with run inspection guidance.
@@ -27,8 +32,9 @@ Areas:
   Setup plan/init default to human-readable read-only output; pass --json for automation. VGX-managed provider configuration is user-global only for OpenCode and Claude; setup apply writes provider config only with --yes and uses the global user DB plus mcp-plus-agents by default. setup reinstall is the explicit safe overwrite path: it replaces only VGXNESS-managed OpenCode entries, preserves unrelated config, and still requires --yes to write.
   Setup status defaults to human-readable read-only output; pass --json for automation. It never writes provider config or executes providers.
   Doctor defaults to human-readable output; pass --json for automation.
-  Verification plans are read-only recommendations only; they never execute commands, write provider config, persist results, mutate SDD artifacts, or infer acceptance.
+  Verification plans are read-only recommendations only; focused tests are the default during iterative work. Full verify/package gates are for release, high-risk, pre-merge, or broad cross-cutting changes. Plans never execute commands, write provider config, persist results, mutate SDD artifacts, or infer acceptance.
   Verification reports are manual file-only SDD verify draft artifacts; save/get never execute commands, contact providers, write provider config, or auto-accept verification.
+  Knowledge commands project SQLite/repository state into an Obsidian workspace. Obsidian MCP is the preferred host transport; standalone CLI export fails fast without an MCP-capable host and only writes filesystem fallback when --workspace filesystem --vault <path> is explicit.
 
   agents register --project <name> --name <name> --description <text> --instructions <text>
   agents register --file <agent.json>
@@ -41,9 +47,9 @@ Areas:
   Seed loading writes only to the local registry; it does not install or write .opencode/, .claude/, or provider config.
 
   opencode preview --provider opencode (--agent <name> | --agent-id <id>) --project <name> --change <id> --phase <phase> [--scope project|personal]
-  OpenCode CLI preview prints the legacy injection preview JSON for inspection; MCP opencode_handoff_preview is the read-only conversation handoff preview and can be paired with opencode_manager_payload for verbose manager payload details.
+  OpenCode CLI preview is a legacy/compatibility read-only preview for inspecting the old combined injection envelope; for daily OpenCode conversation handoff and manager payload details, prefer MCP opencode_handoff_preview paired with opencode_manager_payload. It never writes provider config or executes providers.
 
-  Interactive Home TUI opens from \`vgxness\` in a real terminal; non-TTY use prints safe guidance. Daily SDD progression should happen inside OpenCode through conversation, VGXNESS MCP, and reusable capability subagents; use status/next/sdd continue for read-only CLI guidance.
+  Interactive Home TUI opens from \`vgxness\` in a real terminal; non-TTY use prints safe guidance. Daily SDD progression should happen inside OpenCode or Claude; VGXNESS MCP and SQLite govern state, and capability subagents are available when helpful. Use status/next/sdd continue for read-only CLI guidance.
 
   orchestrator preview --project <name> --intent <text> [--change <id>] [--db <path>]
   Orchestrator preview classifies natural-language requests only; it never executes providers, edits files, records runs, or writes provider config.
@@ -67,9 +73,9 @@ Areas:
   mcp install claude --yes --run-id <id> [--scope user|global|personal] [--db <path>] [--phase <phase>] [--agent-id <id>] [--overwrite-vgxness|--reinstall]
   mcp doctor opencode [--scope user|project] [--project-root <path>]
   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.
+  MCP setup --preview is a legacy/read-only snippet preview; prefer mcp install <provider> --plan for current install planning. 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=deny and native repo tools disabled, and hidden capability agents such as vgxness-explore/vgxness-plan/vgxness-verify with legacy vgxness-sdd-* task aliases; 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 capability agents such as vgxness-explore/vgxness-plan/vgxness-verify with canonical task permissions only; 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/interfaces/cli/cli-helpers.js

@@ -1,7 +1,7 @@
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
-import { openMemoryDatabase } from '../../memory/sqlite/database.js';
-import { prepareMemoryDatabasePath } from '../../memory/storage-paths.js';
+import { openMemoryDatabase } from '../../storage/memory/sqlite/database.js';
+import { prepareMemoryDatabasePath } from '../../storage/memory/storage-paths.js';
 import { validationFailure } from './cli-help.js';
 function openCliDatabase(path) {
     const prepared = prepareMemoryDatabasePath(path);

package/dist/interfaces/cli/commands/agent-skill-dispatcher.js

@@ -1,14 +1,14 @@
-import { AgentRegistryService } from '../../../agents/agent-registry-service.js';
-import { AgentSeedService } from '../../../agents/agent-seed-service.js';
-import { ManagerProfileOverlayService } from '../../../agents/manager-profile-overlay-service.js';
-import { getProviderRenderer } from '../../../agents/renderers/index.js';
-import { ManagerProfileOverlayRepository } from '../../../agents/repositories/manager-profile-overlays.js';
+import { AgentRegistryService } from '../../../application/agents/agent-registry-service.js';
+import { AgentSeedService } from '../../../application/agents/agent-seed-service.js';
+import { ManagerProfileOverlayService } from '../../../application/agents/manager-profile-overlay-service.js';
+import { getProviderRenderer } from '../../../application/agents/renderers/index.js';
 import { createAgentRegistryToolHandlers } from '../../../harness/tools/agents.js';
-import { runBootSkillSeed } from '../../../skills/boot-seed.js';
-import { SkillExportService } from '../../../skills/skill-export-service.js';
-import { SkillIndexService } from '../../../skills/skill-index-service.js';
-import { SkillRegistryService } from '../../../skills/skill-registry-service.js';
-import { SkillStatusService } from '../../../skills/skill-status-service.js';
+import { ManagerProfileOverlayRepository } from '../../../storage/agents/repositories/manager-profile-overlays.js';
+import { runBootSkillSeed } from '../../../application/skills/boot-seed.js';
+import { SkillExportService } from '../../../application/skills/skill-export-service.js';
+import { SkillIndexService } from '../../../application/skills/skill-index-service.js';
+import { SkillRegistryService } from '../../../application/skills/skill-registry-service.js';
+import { SkillStatusService } from '../../../application/skills/skill-status-service.js';
 import { csvFlag, instructionKindFlag, jsonFlag, optionalJsonFlag, optionalModeFlag, optionalScopeFlag, optionalSkillEvaluationResultStatusFlag, optionalSkillImprovementProposalStatusFlag, optionalSkillResolutionUsageFlag, optionalSkillTargetTypeFlag, optionalSkillVersionStatusFlag, optionalStringFlag, requiredFlag, scopeFlag, skillEvaluationResultStatusFlag, skillSourceFromFlags, skillTargetTypeFlag, skillUsageOutcomeFlag, } from '../cli-flags.js';
 import { usageFailure, validationFailure } from '../cli-help.js';
 import { jsonResult, readJsonFile, resultFailure } from '../cli-helpers.js';

package/dist/interfaces/cli/commands/index.js

@@ -2,6 +2,7 @@ export { runCodeContextCommand } from './code-context-dispatcher.js';
 export { runAgentCommand, runSkillCommand, runSubagentCommand } from './agent-skill-dispatcher.js';
 export { runDefaultInteractiveEntrypoint } from './interactive-entrypoint-dispatcher.js';
 export { runDoctorAliasCommand, runMcpDoctorCommand, runMcpDoctorOpenCodeCommand, runMcpInstallCommand, runMcpSetupCommand } from './mcp-dispatcher.js';
+export { runKnowledgeWorkspaceCommand } from './knowledge-workspace-dispatcher.js';
 export { runMemoryCommand, runMemoryImportCommand, runOpenCodeCommand, runOrchestratorCommand, runSddCommand } from './memory-sdd-dispatcher.js';
 export { runApprovalsCommand, runPermissionsCommand, runRunsCommand } from './run-permission-dispatcher.js';
 export { applySetupPlanInput, collectRunDetails, collectRunInsights, createSetupLifecycleService, promptSetupWizard, readSetupStatus, runHomeTuiCommand, runInitCommand, runSetupApplyCommand, runSetupBackupCommand, runSetupLifecycleCommand, runSetupPlanCommand, runSetupReinstallApplyCommand, runSetupReinstallCommand, runSetupRollbackCommand, setupMcpEvidence, setupPlanInputFromFlags, } from './setup-dispatcher.js';