@mod-computer/cli 0.1.1 → 0.2.1

package/dist/services/modignore-service.js

@@ -1,3 +1,5 @@
+// glassware[type="implementation", id="impl-cli-add-modignore-service--ae506406", requirements="requirement-cli-add-ignore-modignore--92ba9b60,requirement-cli-add-ignore-gitignore--054c4b53,requirement-cli-add-ignore-default--facbedfe,requirement-cli-add-ignore-negation--79b9bf48"]
+// spec: packages/mod-cli/specs/add.md
 import fs from 'fs';
 import path from 'path';
 export class ModIgnoreService {

package/dist/stores/use-workspaces-store.js

@@ -1,4 +1,5 @@
 import { create } from 'zustand';
+import { readConfig } from '../lib/storage.js';
 export const useWorkspacesStore = create((set) => ({
     workspaces: [],
     loading: false,
@@ -6,20 +7,41 @@ export const useWorkspacesStore = create((set) => ({
     fetchWorkspaces: async (repo) => {
         set({ loading: true, error: null });
         try {
-            // const rootDocId = '3RrsuQCaieHkXPUNSsq3UhEAxnHW';
-            // const rootDocId = 'rY75AHsEfNx1vKnrtpdfmo5dyjr';
-            // const rootDocId = '2a9anXJNoBxstgrhRJfkBGS3uxs';
-            // const rootDocId = '3pW2EWyQPrshmj4Y1KqEo7sMTqxV';
-            const rootDocId = 'KRkJrMQeNQo9bTwSsoKZBxcpz1y';
-            const wsHandle = await repo.find(rootDocId);
-            const doc = wsHandle.doc();
-            const workspacesRaw = doc.workspaces || [];
-            const workspacesList = (Array.isArray(workspacesRaw)
-                ? workspacesRaw
-                : []).map((w) => ({
-                id: w.id || '',
-                name: w.name || w.title || 'Untitled',
-            }));
+            const config = readConfig();
+            const userDocId = config.auth?.userDocId;
+            if (!userDocId) {
+                set({ workspaces: [], error: 'Not authenticated. Run `mod auth login` first.' });
+                return;
+            }
+            // Fetch workspaces from user document
+            const userHandle = await repo.find(userDocId);
+            await userHandle.whenReady();
+            const userDoc = userHandle.doc();
+            if (!userDoc) {
+                set({ workspaces: [], error: 'Could not load user document.' });
+                return;
+            }
+            const workspaceIds = userDoc.workspaceIds || [];
+            const workspacesList = [];
+            // Load workspace metadata for each workspace
+            for (const wsId of workspaceIds) {
+                try {
+                    const wsHandle = await repo.find(wsId);
+                    await wsHandle.whenReady();
+                    const ws = wsHandle.doc();
+                    workspacesList.push({
+                        id: wsId,
+                        name: ws?.title || ws?.name || 'Untitled',
+                    });
+                }
+                catch {
+                    // Workspace might not be available, add with just ID
+                    workspacesList.push({
+                        id: wsId,
+                        name: 'Untitled',
+                    });
+                }
+            }
             set({ workspaces: workspacesList });
         }
         catch (err) {

package/dist/types/add-types.js

@@ -0,0 +1,99 @@
+// glassware[type="implementation", id="impl-cli-add-types--03cec234", requirements="requirement-cli-add-types--e6c546b5"]
+// spec: packages/mod-cli/specs/add.md
+/**
+ * Create a typed AddError
+ */
+export function createAddError(code, message, path, cause) {
+    return { code, message, path, cause };
+}
+/**
+ * Check if an error is an AddError
+ */
+export function isAddError(error) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        'code' in error &&
+        'message' in error);
+}
+/**
+ * Error strategy mapping - defines how each error type should be handled
+ */
+export const ERROR_STRATEGIES = {
+    // Input validation - abort
+    INVALID_PATH: { action: 'abort', userMessage: 'Show error, exit' },
+    PATH_OUTSIDE_WORKSPACE: { action: 'abort', userMessage: 'Show error, exit' },
+    NOT_CONNECTED: { action: 'abort', userMessage: 'Show error, suggest `mod init`' },
+    // File validation - skip
+    FILE_TOO_LARGE: { action: 'skip', userMessage: 'Warning, continue' },
+    PERMISSION_DENIED: { action: 'skip', userMessage: 'Warning, continue' },
+    ENCODING_ERROR: { action: 'fallback', userMessage: 'Auto-convert to binary, continue' },
+    CIRCULAR_SYMLINK: { action: 'skip', userMessage: 'Warning, continue' },
+    // Workspace errors - abort/skip
+    WORKSPACE_NOT_FOUND: { action: 'abort', userMessage: 'Show error, exit' },
+    FOLDER_NOT_FOUND: { action: 'skip', userMessage: 'Warning, continue' },
+    FOLDER_LIMIT_EXCEEDED: { action: 'skip', userMessage: 'Warning, continue' },
+    // Automerge errors - retry
+    DOC_CREATE_FAILED: { action: 'retry', maxRetries: 3, userMessage: 'Retry, then skip' },
+    DOC_UPDATE_FAILED: { action: 'retry', maxRetries: 3, userMessage: 'Retry, then skip' },
+    SYNC_FAILED: { action: 'retry', maxRetries: 3, userMessage: 'Retry, then skip' },
+    HANDLE_TIMEOUT: { action: 'retry', maxRetries: 3, userMessage: 'Retry, then skip' },
+    // System errors - abort
+    OUT_OF_MEMORY: { action: 'abort', userMessage: 'Show error, suggest smaller batch' },
+    CANCELLED: { action: 'abort', userMessage: 'Show progress, exit' },
+    UNKNOWN: { action: 'skip', userMessage: 'Log error, continue' },
+};
+/**
+ * Get the error strategy for an error code
+ */
+export function getErrorStrategy(code) {
+    return ERROR_STRATEGIES[code];
+}
+/**
+ * Constants for add operation
+ */
+export const ADD_CONSTANTS = {
+    /** Maximum concurrent file document creations */
+    PARALLEL_FILE_LIMIT: 10,
+    /** Maximum binary file size in bytes (100KB) */
+    MAX_BINARY_SIZE: 100 * 1024,
+    /** Progress update throttle in ms */
+    PROGRESS_THROTTLE_MS: 100,
+    /** Retry attempts for document operations */
+    MAX_RETRIES: 3,
+    /** Backoff multiplier for retries in ms */
+    RETRY_BACKOFF_MS: 100,
+    /** Memory limit in bytes (200MB) */
+    MEMORY_LIMIT: 200 * 1024 * 1024,
+    /** Small add threshold (no progress bar) */
+    SMALL_ADD_THRESHOLD: 100,
+    /** Medium add threshold (spinner) */
+    MEDIUM_ADD_THRESHOLD: 1000,
+};
+/**
+ * Known text file extensions
+ */
+export const TEXT_EXTENSIONS = new Set([
+    '.txt', '.md', '.js', '.ts', '.tsx', '.jsx', '.json', '.yaml', '.yml',
+    '.toml', '.xml', '.html', '.css', '.scss', '.py', '.rb', '.go', '.rs',
+    '.java', '.c', '.cpp', '.h', '.sh', '.sql', '.graphql', '.vue', '.svelte',
+    '.astro', '.php', '.kt', '.scala', '.swift', '.dockerfile', '.tf', '.hcl',
+    '.ps1', '.bat', '.cmd', '.env', '.gitignore', '.editorconfig', '.prettierrc',
+    '.eslintrc', '.babelrc', 'makefile', 'dockerfile', '.lock'
+]);
+/**
+ * Default ignore patterns
+ */
+export const DEFAULT_IGNORE_PATTERNS = [
+    'node_modules/',
+    '.git/',
+    'dist/',
+    'build/',
+    '.mod/',
+    '*.log',
+    '.DS_Store',
+    'Thumbs.db',
+    '.env',
+    '.env.local',
+    '.env.*',
+    'secrets/',
+];

package/dist/types/config.js

@@ -1,4 +1,4 @@
-// glassware[type=implementation, id=cli-config-types, requirements=req-cli-storage-config-1,req-cli-storage-config-2]
+// glassware[type="implementation", id="cli-config-types--dd74d8f7", requirements="requirement-cli-storage-config-1--6e0f731a,requirement-cli-storage-config-2--f95aa032"]
 /**
  * Default settings values.
  */

package/dist/types/workspace-connection.js

@@ -1,2 +1,53 @@
-// glassware[type=implementation, id=cli-workspace-connection-types, requirements=req-cli-storage-conn-1,req-cli-storage-conn-3]
-export {};
+// glassware[type="implementation", id="cli-workspace-connection-types--13014cb2", requirements="requirement-cli-storage-conn-1--ce1b8ad9,requirement-cli-storage-conn-3--6536b6b2,requirement-cli-init-data-1--9f55757e"]
+// glassware[type="implementation", id="impl-cli-ws-type-connection--5c50b266", requirements="requirement-cli-ws-type-connection--bc33fa7a,requirement-cli-ws-conn-path--1a1a1301,requirement-cli-ws-conn-workspace-id--39acf87e,requirement-cli-ws-conn-name--791b4633,requirement-cli-ws-conn-connected-at--2ac4aba8,requirement-cli-ws-conn-last-synced--9b1ee720"]
+// spec: packages/mod-cli/specs/workspaces.md, packages/mod-cli/specs/initialization.md
+import path from 'path';
+// ISO 8601 regex pattern for timestamp validation
+const ISO8601_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?$/;
+// glassware[type="implementation", id="impl-cli-ws-conn-validate--c0c28675", requirements="requirement-cli-ws-conn-validate-path--1278682d,requirement-cli-ws-conn-validate-id--826810aa,requirement-cli-ws-conn-validate-timestamps--77971858"]
+/**
+ * Validate a WorkspaceConnection object
+ */
+export function validateWorkspaceConnection(conn) {
+    const errors = [];
+    if (!conn || typeof conn !== 'object') {
+        return {
+            valid: false,
+            errors: [{ field: 'root', message: 'Connection must be an object', code: 'REQUIRED' }]
+        };
+    }
+    const c = conn;
+    // Validate path - must be absolute
+    if (typeof c.path !== 'string' || !c.path) {
+        errors.push({ field: 'path', message: 'path is required', code: 'REQUIRED' });
+    }
+    else if (!path.isAbsolute(c.path)) {
+        errors.push({ field: 'path', message: 'path must be absolute', code: 'INVALID_PATH' });
+    }
+    // Validate workspaceId - must be non-empty string
+    if (typeof c.workspaceId !== 'string' || !c.workspaceId) {
+        errors.push({ field: 'workspaceId', message: 'workspaceId is required', code: 'REQUIRED' });
+    }
+    // Validate workspaceName - must be non-empty string
+    if (typeof c.workspaceName !== 'string' || !c.workspaceName) {
+        errors.push({ field: 'workspaceName', message: 'workspaceName is required', code: 'REQUIRED' });
+    }
+    // Validate connectedAt - must be ISO 8601
+    if (typeof c.connectedAt !== 'string' || !c.connectedAt) {
+        errors.push({ field: 'connectedAt', message: 'connectedAt is required', code: 'REQUIRED' });
+    }
+    else if (!ISO8601_REGEX.test(c.connectedAt)) {
+        errors.push({ field: 'connectedAt', message: 'connectedAt must be ISO 8601 format', code: 'INVALID_FORMAT' });
+    }
+    // Validate lastSyncedAt - must be ISO 8601
+    if (typeof c.lastSyncedAt !== 'string' || !c.lastSyncedAt) {
+        errors.push({ field: 'lastSyncedAt', message: 'lastSyncedAt is required', code: 'REQUIRED' });
+    }
+    else if (!ISO8601_REGEX.test(c.lastSyncedAt)) {
+        errors.push({ field: 'lastSyncedAt', message: 'lastSyncedAt must be ISO 8601 format', code: 'INVALID_FORMAT' });
+    }
+    return {
+        valid: errors.length === 0,
+        errors
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@mod-computer/cli",
-	"version": "0.1.1",
+	"version": "0.2.1",
 	"license": "MIT",
 	"bin": {
 		"mod": "dist/cli.bundle.js"
@@ -22,12 +22,13 @@
 		"commands"
 	],
 	"dependencies": {
+		"@ai-sdk/anthropic": "2.0.0-beta.3",
+		"@ai-sdk/openai": "2.0.0-beta.5",
 		"@automerge/automerge": "^3.1.2",
 		"@automerge/automerge-repo": "^2.3.1",
 		"@automerge/automerge-repo-network-websocket": "^2.3.1",
 		"@automerge/automerge-repo-storage-nodefs": "^2.3.1",
-		"@ai-sdk/anthropic": "2.0.0-beta.3",
-		"@ai-sdk/openai": "2.0.0-beta.5",
+		"@inquirer/prompts": "^8.1.0",
 		"ai": "5.0.0-beta.11",
 		"chokidar": "^4.0.3",
 		"dotenv": "^17.1.0",
@@ -35,15 +36,15 @@
 		"ink-select-input": "^6.2.0",
 		"ink-text-input": "^6.0.0",
 		"meow": "^11.0.0",
+		"ora": "^9.0.0",
 		"react": "19.1.0",
 		"react-dom": "19.1.0",
 		"zustand": "^5.0.6"
 	},
 	"devDependencies": {
-		"@mod/mod-core": "workspace:*",
-		"esbuild": "^0.24.0",
 		"@babel/cli": "^7.21.0",
 		"@babel/preset-react": "^7.18.6",
+		"@mod/mod-core": "workspace:*",
 		"@types/ink": "^2.0.3",
 		"@types/ink-select-input": "^3.0.5",
 		"@types/ink-text-input": "^2.0.5",
@@ -52,6 +53,7 @@
 		"@types/react": "^19.1.8",
 		"@vdemedes/prettier-config": "^2.0.1",
 		"chalk": "^5.2.0",
+		"esbuild": "^0.24.0",
 		"eslint-config-xo-react": "^0.27.0",
 		"eslint-plugin-react": "^7.32.2",
 		"eslint-plugin-react-hooks": "^4.6.0",

package/commands/execute.md

@@ -1,156 +0,0 @@
----
-version: 2.0.0
-updated: 2026-01-03
-description: Execute specification with complete traceability implementation
----
-
-# Specification Execution with Complete Traceability
-
-Given this specification file: ".mod/specs/<optional-folder>/$ARGUMENTS"
-
-## Branch Context and Specification Setup
-
-**Automatic Branch Detection and Context Gathering:**
-
-**If no specification argument provided:**
-1. **Check active branch** for linked specification:
-   ```bash
-   mod branch status
-   # Should show active branch and linked specification
-   ```
-2. **Error handling** for lightweight branches:
-   ```bash
-   # If current branch has no specification:
-   # > Current branch "fix-auth-timeout" is a lightweight branch with no specification
-   # > Options:
-   # > 1. Link specification: mod branch spec-link <spec-file>
-   # > 2. Create specification branch: mod branch create feature-<name> --spec <spec-file>
-   # > 3. Switch to specification branch: mod branch switch <spec-branch>
-   ```
-
-**If specification argument provided (e.g., `branching-cli.spec.md`):**
-1. **Auto-switch to specification branch**:
-   ```bash
-   # Check if corresponding branch exists
-   mod branch list | grep "feature-.*branching-cli"
-
-   # If exists, switch to it
-   mod branch switch feature-mod-cli-branching-cli
-
-   # If doesn't exist, create it
-   mod branch create feature-mod-cli-branching-cli --spec mod-cli/branching-cli.spec.md
-   ```
-2. **Verify branch setup**:
-   ```bash
-   mod branch status
-   # Should confirm specification branch is active and linked
-   ```
-
-**Context Gathering (Automatic):**
-1. **Implementation Progress**: `mod branch status` shows current implementation changes
-2. **Specification Requirements**: `mod status <spec-name>.spec.md` shows requirements and traceability
-3. **Coverage Analysis**: `glassware` shows which code has implementation traces
-
-## Pre-Execution Analysis
-
-**BEFORE implementation:**
-1. Read and fully understand the complete specification, including all sub-requirements
-2. Parse all ARCH-*, BEH-*, DATA-*, and TEST-* requirements for dependency analysis
-3. Identify numbered sub-requirements (e.g., BEH-AUTH-1.1, BEH-AUTH-1.2) for granular execution
-4. Create implementation plan prioritizing ARCH → DATA → BEH → TEST requirements
-
-**Understanding existing code changes:**
-5. Use `mod branch status` to see what code changes have already been made on this branch
-6. Run `glassware` to understand spec traceability coverage of existing code on branch
-
-## Mandatory Traceability Implementation
-
-**CRITICAL: Use glassware annotations for all traceability**
-
-### Glassware Annotation Format
-
-**In Markdown specs/requirements:**
-```markdown
-The system must validate user credentials. <glassware type="requirement" id="REQ-AUTH-1" />
-```
-
-**In TypeScript implementations:**
-```typescript
-// glassware[type=implementation, id=unique-impl-id, requirements=REQ-ID]
-```
-
-### Complexity-Based Traceability Standards
-- **Method-Level (Default)**: Single glassware comment for simple functions (<10 lines, no branching)
-- **Line-Level (Complex)**: Detailed glassware comments for complex logic (>10 lines, branching, error handling)
-- **Business Logic Priority**: Always use line-level traces for business logic patterns regardless of complexity
-
-### Granularity Decision Rules
-**For each function, analyze and apply:**
-
-1. **Business Logic Check** - Does function name/purpose include: validate, auth, pay, charge, encrypt, save, persist?
-   → If YES: Always use **line-level** traces
-
-2. **Complexity Check** - Count lines of actual code (exclude comments/whitespace):
-   → If >10 lines OR has conditionals (if/switch/try/for/while): Use **line-level** traces
-   → If ≤10 lines AND no conditionals: Use **method-level** traces
-
-3. **Error Handling Check** - Does function have try-catch or multiple return paths?
-   → If YES: Use **line-level** traces
-
-### Method-Level Example (Simple Function)
-```typescript
-// glassware[type=implementation, id=validate-user, requirements=REQ-AUTH-1]
-function validateUser(email: string, password: string): boolean {
-  return bcrypt.compare(password, getStoredHash(email));
-}
-```
-
-### Line-Level Example (Complex Function)
-```typescript
-function processPayment(order: Order, card: CreditCard): PaymentResult {
-  // glassware[type=implementation, id=validate-order, requirements=REQ-PAY-1]
-  if (order.amount <= 0 || !SUPPORTED_CURRENCIES.includes(order.currency)) {
-    throw new ValidationError("Invalid order parameters");
-  }
-
-  // glassware[type=implementation, id=fraud-check, requirements=REQ-PAY-2]
-  const fraudScore = await fraudDetection.analyze(card, order);
-  if (fraudScore > FRAUD_THRESHOLD) {
-    // glassware[type=implementation, id=fraud-logging, requirements=REQ-PAY-3]
-    await auditLog.record('fraud_detected', { order: order.id, score: fraudScore });
-    throw new FraudError("Transaction blocked by fraud detection");
-  }
-
-  // glassware[type=implementation, id=process-charge, requirements=REQ-PAY-4]
-  return await paymentGateway.charge(card, order.amount);
-}
-```
-
-## Execution Workflow
-
-**For each implementation cycle, MUST apply this process:**
-1. **Analyze Complexity**: Count lines, branches, and business logic patterns
-2. **Apply Granularity Rules**: Use method-level for simple functions, line-level for complex
-3. **Business Logic Override**: Always apply line-level traces for business logic patterns
-4. **Embed During Generation**: Add glassware traces as code is generated, not afterward
-5. **Test Progress**: Run `glassware` to verify traceability coverage
-6. **Iterate**: Continue implementing and tracing until all requirements show as implemented
-
-## Real-Time Quality Gates
-
-**Execution agents MUST enforce these standards:**
-- **Specification Coverage**: ≥90% of sub-requirements implemented
-- **Appropriate Granularity**: Complex functions have line-level traces, simple functions have method-level
-- **Business Logic Traceability**: All business logic has detailed line-level glassware traces
-- **Invalid References**: 0 glassware comments pointing to non-existent requirements
-
-## Success Criteria
-
-✅ **Complete Implementation**: All numbered sub-requirements implemented and working
-✅ **Full Traceability**: Every implementation decision traced to specific sub-requirement
-✅ **Status Verification**: `glassware` shows all requirements as implemented
-✅ **Quality Gates Passed**: Coverage and traceability thresholds met
-✅ **Test Coverage**: All TEST-* requirements implemented with glassware traces
-✅ **Zero Orphaned Code**: All new code has valid glassware requirement references
-
-**CRITICAL**: Run `glassware` before and after each implementation phase to verify progress. Additionally, use `mod branch status` to understand what code changes were made for the spec. Do not mark tasks complete until glassware shows all requirements implemented.

package/commands/overview.md

@@ -1,233 +0,0 @@
----
-version: 2.0.0
-updated: 2026-01-03
-description: Generate workspace specification scaffolding and overview
----
-
-# Workspace Specification Scaffolding
-
-## Command Modes
-
-**Two-Step Process:**
-
-1. **Overview Mode** (no arguments): `workspace-spec`
-   - Performs full codebase analysis
-   - Generates overview of current architecture  
-   - Plans specification structure
-   - Outputs proposed organization without creating files
-
-2. **Implementation Mode** (with argument): `workspace-spec <workspace-name>` or `workspace-spec overview.spec.md`
-   - Creates the planned specification directory structure
-   - Generates template files based on analysis from overview mode
-   - Implements the full scaffolding process
-
----
-
-### Overview Mode (No Arguments)
-
-When no arguments are provided, perform analysis and planning only:
-
-**ANALYSIS TASKS:**
-1. Analyze existing codebase architecture and component organization
-2. Scan `.mod/specs/` (or existing spec directories) for current specification structure and patterns  
-3. Identify feature domains from component names and folder hierarchy
-4. Detect specification gaps where components exist but specifications are missing
-5. Generate hierarchical specification organization plan
-
-**OUTPUT OVERVIEW:**
-- Current codebase architecture summary
-- Identified components and their organization
-- Existing specification coverage analysis
-- Project directory hierarchy map with key ownership notes
-- Recommendation for workspace name and organization
-
-**NO FILES CREATED** - This mode only analyzes and plans.
-
----
-
-### Implementation Mode (With Arguments)
-
-When arguments are provided (`workspace-spec <workspace-name>` or `workspace-spec overview.spec.md`):
-
-**Argument Handling:**
-- If argument is "overview.spec.md" → Use default workspace name based on project directory
-- If argument is a custom name → Use provided workspace name: "$ARGUMENTS"
-- Both cases proceed with full scaffolding implementation
-
-## Workspace Scaffolding Process
-
-### 1. Codebase Architecture Discovery
-
-**Project Structure Analysis**:
-- Scan project directory for all components/modules and their organization
-- Identify core components (main application logic, shared libraries)
-- Categorize feature components (domain-specific functionality, user-facing features)
-- Discover infrastructure components (utilities, services, configuration, deployment)
-
-**Existing Specification Audit**:
-- List all current `.mod/specs/` folders and specification files (or detect existing spec directories)
-- Identify coverage gaps where components have no specifications
-- Analyze specification quality and completion status
-- Map specification relationships and dependencies
-
-### 2. Project Hierarchy Mapping
-
-**Project Organization Deliverable**:
-- Enumerate the actual workspace directories (packages, apps, services, docs, tooling)
-- Highlight the major subdirectories under the focus package (e.g., `source/commands`, `source/services`, `tests/containers`)
-- Note ownership and responsibility per directory so downstream specs know where behavior lives
-
-**Suggested Output Format**:
-```
-packages/
-└── [workspace-name]/
-    ├── source/
-    │   ├── app.tsx
-    │   ├── cli.tsx
-    │   ├── commands/               # Headless commands
-    │   ├── containers/             # Ink UI views
-    │   ├── services/               # Shared domain logic
-    │   ├── components/             # Reusable Ink components
-    │   ├── stores/                 # Zustand state
-    │   └── shims/                  # Polyfills/adapters
-    ├── tests/
-    │   ├── services/
-    │   ├── containers/
-    │   └── _harness/
-    ├── docs/
-    ├── dist/
-    ├── README.md
-    ├── package.json
-    └── vitest.config.ts
-```
-
-Use this hierarchy to anchor the overview narrative, tie directories to functionality, and call out gaps (e.g., missing tests folder, duplicated services). This replaces the previous "proposed spec tree" so the overview focuses on the real project layout before any scaffolding occurs.
-
-### 3. Template Population System
-
-**Generic Specification Template Structure for Each Specification**:
-```markdown
----
-title: [feature-name]
-type: specification
----
-# [Feature Name] Specification
-
-## Abstract
-[One-sentence system summary with key capabilities and scale targets]
-
-## Motivation
-### Current Problems
-- [Specific problem this feature solves]
-
-### Business Impact  
-- [Value delivered and success metrics]
-
-## Approach
-[High-level solution architecture and key technical decisions]
-
-## UX Requirements (UX-*)
-[UI components, user flows, and accessibility]
-
-## Application Requirements (APP-*)  
-[Business logic, workflows, and validation rules]
-
-## Integration Requirements (INT-*)
-[APIs, external services, and data exchange]
-
-## Infrastructure Requirements (INFRA-*)
-[System architecture, deployment, and scaling]
-
-## Quality Requirements (QUAL-*)
-[Testing, performance, and security criteria]
-
-## Expected Glassware Trace Formats
-**Method-Level**: `// glassware[type=implementation, id=unique-id, requirements=REQ-CATEGORY-N]`
-**Line-Level**: Same format, placed above specific logic blocks
-```
-
-### 4. Intelligent Content Generation
-
-**For Each Component**:
-1. **Analyze project files** (package.json, pyproject.toml, Cargo.toml, etc.) for dependencies and scripts to understand functionality
-2. **Scan source code** for main classes, services, and architectural patterns
-3. **Identify integration points** through import analysis and API usage
-4. **Generate initial requirements** based on discovered functionality patterns
-5. **Create placeholder specifications** with discovered structure and TODO sections
-
-**Business Logic Pattern Detection**:
-- Authentication/authorization functions → Security specification requirements
-- Data persistence operations → Data management specification requirements  
-- External API integrations → Integration specification requirements
-- UI components and workflows → UX specification requirements
-
-### 5. Cross-Component Dependency Mapping
-
-**Integration Analysis**:
-- Map import relationships between components to identify integration specifications needed
-- Identify shared types and interfaces requiring API contract specifications
-- Discover common patterns requiring cross-cutting concern specifications
-- Generate integration requirement matrix for multi-component features
-
-**Dependency Documentation**:
-- Create visual dependency graph in `requirements-matrix.md`
-- Document shared service contracts in `integration-points.md`
-- Identify specification completion priorities based on dependency criticality
-
-## Scaffolding Execution Workflow
-
-### Phase 1: Discovery and Planning
-1. Run codebase analysis to understand current architecture
-2. Generate proposed specification folder structure
-3. Display plan to user with component coverage analysis
-4. Identify critical specification gaps requiring immediate attention
-
-### Phase 2: Structure Creation  
-1. Detect existing specification directory structure (`.mod/specs/`) or create `.mod/specs/` if none exists
-2. Create hierarchical folder structure within the specification directory
-3. Generate template specification files with component-specific content
-4. Populate initial requirements based on code analysis
-5. Create cross-reference documentation and dependency matrix
-
-### Phase 3: Integration Setup
-1. Update existing specifications with cross-component integration requirements  
-2. Generate shared specification files for cross-cutting concerns
-3. Create workspace overview documentation linking all specifications
-4. Establish specification completion roadmap with priorities
-
-### Phase 4: Validation and Reporting
-1. Validate all generated specification files for template compliance
-2. Check cross-reference integrity between specifications
-3. Generate workspace specification summary report
-4. Provide next steps for specification completion and implementation
-
-## Quality Standards
-
-**Template Compliance**:
-- All specifications include complete template structure with all required sections
-- Requirement numbering follows category prefix standards (UX-*, APP-*, INT-*, INFRA-*, QUAL-*)
-- Expected glassware trace formats defined for optimal traceability integration
-- Cross-component dependencies properly documented and referenced
-
-**Scaffolding Completeness**:
-- 100% component coverage - every significant component has at least one specification
-- Critical integration points identified and documented
-- Shared concerns extracted into cross-cutting specifications
-- Specification priorities established based on dependency analysis
-
-**Integration Readiness**:
-- Generated specifications ready for `/execute` command implementation
-- Clear requirement traceability paths established
-- Component boundaries and contracts clearly defined
-- Cross-component workflows properly specified
-
-## Success Criteria
-
-✅ **Complete Component Coverage**: Every significant component in workspace has specification structure
-✅ **Hierarchical Organization**: Logical folder structure mirrors codebase architecture  
-✅ **Template Consistency**: All specifications follow generic template standards
-✅ **Integration Documentation**: Cross-component dependencies and contracts specified
-✅ **Implementation Ready**: Generated specifications contain actionable requirements ready for `/execute`
-✅ **Quality Foundation**: Specification quality standards established for workspace
-
-**Result**: Complete workspace specification scaffolding with hierarchical organization, template consistency, and integration documentation ready for systematic implementation via `/execute` commands.