@garyr/pt-cli 0.32.1 → 0.36.4

package/dist/substitute.js

@@ -30,7 +30,11 @@ export async function processCopyFiles(templateRoot, resolvedDest, template, var
                 console.log(chalk.gray(`  [DRY RUN] Would recursively copy directory ${copyFile.src} → ${copyFile.dest}`));
             }
             else {
-                copyDirRecursive(srcPath, destPath, variables, copyFile.substitute_variables || false, copyFile.chmod);
+                const dirSubstitute = !!(copyFile.substitute_variables === true || (copyFile.substitute_variables === undefined &&
+                    template.variables &&
+                    template.variables.length > 0 &&
+                    Object.keys(variables).length > 0));
+                copyDirRecursive(srcPath, destPath, variables, dirSubstitute, copyFile.chmod);
             }
             console.log(chalk.green(`  ✓ ${copyFile.dest} (recursive)`));
         }
@@ -38,7 +42,11 @@ export async function processCopyFiles(templateRoot, resolvedDest, template, var
             // Single file copy
             if (dryRun) {
                 console.log(chalk.gray(`  [DRY RUN] Would copy ${copyFile.src} → ${copyFile.dest}`));
-                if (copyFile.substitute_variables) {
+                const drySubstitute = !!(copyFile.substitute_variables === true || (copyFile.substitute_variables === undefined &&
+                    template.variables &&
+                    template.variables.length > 0 &&
+                    Object.keys(variables).length > 0));
+                if (drySubstitute) {
                     console.log(chalk.gray(`  [DRY RUN] Would substitute variables in ${copyFile.dest}`));
                 }
                 if (copyFile.chmod) {
@@ -49,7 +57,13 @@ export async function processCopyFiles(templateRoot, resolvedDest, template, var
             // Ensure destination directory exists
             fs.mkdirSync(path.dirname(destPath), { recursive: true });
             let content = fs.readFileSync(srcPath, 'utf-8');
-            if (copyFile.substitute_variables) {
+            // Default to substituting if substitute_variables is true, OR if it's undefined AND the template defines variables.
+            // If substitute_variables is explicitly false, do not substitute.
+            const shouldSubstitute = !!(copyFile.substitute_variables === true || (copyFile.substitute_variables === undefined &&
+                template.variables &&
+                template.variables.length > 0 &&
+                Object.keys(variables).length > 0));
+            if (shouldSubstitute) {
                 content = substituteVariables(content, variables);
             }
             fs.writeFileSync(destPath, content);

package/doc/configuration.md

@@ -8,6 +8,10 @@ Config is stored at `~/.pt/config.yaml` and contains:
 - `ignore`: Global folder ignore patterns for `pt learn`
 - `variables`: Global variable suggestions for `pt learn` (name, prompt, default, required)
 
+## Security Policy
+
+Please see [[security]].
+
 ## Template Variables
 
 When learning a template, you can define variables that will be prompted during initialization:
@@ -52,6 +56,13 @@ If the directory contains a `.pt-template.json` or `template.json` file with a `
 2. Manually edit `~/.pt/config.yaml` to refine `copy_files`, `post_config` commands, or add specific `chmod` requirements.
 3. Alternatively, initialize a temporary project from your learned template (`pt init`), refine it manually, and then use `pt update` from that directory to "re-learn" the refined state.
 
+**Security Note:** All post-config commands are subject to security validation:
+- Dangerous commands (e.g., `curl`, `python`, `chmod`) trigger warnings with 5-second cancellation
+- Absolute blocks (e.g., `sudo`, `rm -rf`, `dd`) are never allowed
+- Rate limiting prevents runaway execution (50 commands per run)
+- Execution timeout (30 seconds) prevents hung processes
+- All events are logged to `~/.pt/security-audit.log`
+
 ```
 javascript:  [git init, npm install]
 python:      [git init, python -m venv .venv, pip install -r requirements.txt]

package/doc/security.md

@@ -0,0 +1,132 @@
+# Security Guide
+
+## Overview
+
+`pt-cli` implements a multi-layered security model to protect users when running post-config commands and downloading remote templates. The system uses a warning-based approach rather than strict blocking, allowing legitimate workflows while providing clear warnings for potentially dangerous operations.
+
+## Security Policy Configuration
+
+Security settings are configured in `~/.pt/config.yaml` under the `security` key:
+
+```yaml
+security:
+  securityLevel: "warn"  # "warn" (default) or "strict"
+  trustedSources:
+    - "github.com/garyritchie"
+    - "git.lyonritchie.com/garyritchie"
+    - "github.com/lyonritchie"
+  maxExecutionTime: 30000  # 30 seconds per command
+  maxCommandsPerRun: 50    # rate limit per init session
+  enableAuditLogging: true # write events to security-audit.log
+```
+
+### Security Levels
+
+- **`warn`** (default): Warning-based approach with cancellation prompts
+- **`strict`**: More conservative defaults, enabled by default for new installations
+
+### Trusted Sources
+
+When downloading templates from remote URLs, `pt-cli` verifies the source against the `trustedSources` list. Untrusted sources trigger a warning and require explicit user confirmation before proceeding.
+
+## Command Security
+
+### Absolute Blocks (Never Allowed)
+
+The following commands are **always blocked** regardless of security level:
+
+- `sudo`, `su`, `su -` (privilege escalation)
+- `dd`, `mkfs`, `fdisk` (disk operations)
+- `rm -rf /`, `rm -r --no-preserve-root` (massive deletion)
+- `eval`, `exec`, `source` (code execution)
+
+### Dangerous Commands (Warning Only)
+
+The following commands trigger a **5-second countdown** with CTRL+C cancellation:
+
+- `curl`, `wget`, `wget -O` (remote downloads)
+- `bash`, `sh`, `python`, `python3`, `node -e`, `node -p` (script execution)
+- `chmod 777`, `chmod -R`, `chmod +x`, `chmod 755`, `chmod 644` (permission changes)
+
+**Example interaction:**
+
+```bash
+⚠️  WARNING: This command may be dangerous: npm install
+   Press CTRL+C to cancel, or wait 5s to continue...
+```
+
+### Rate Limiting
+
+- **50 commands per run**: Prevents runaway command execution
+- If limit is reached, subsequent commands are skipped with a warning
+
+### Execution Timeout
+
+- **30 seconds per command**: Prevents hung processes
+- Timed-out commands are logged and skipped
+
+## Remote Template Security
+
+When downloading templates from remote URLs:
+
+1. **Source Verification**: Checks against `trustedSources` list
+2. **File Size Validation**: Maximum 50MB download limit
+3. **Archive Extraction**: Extracts to secure temporary directory
+4. **Audit Logging**: All downloads are logged with timestamps and outcomes
+
+## Audit Logging
+
+All security events are logged to `~/.pt/security-audit.log`:
+
+```
+2026-06-27T10:01:23.456Z [WARNING] dangerous_command: npm install | type: javascript | status: warning
+2026-06-27T10:01:24.123Z [BLOCKED] command_blocked: sudo rm -rf / | type: all | status: blocked
+2026-06-27T10:01:25.789Z [INFO] template_loaded: https://github.com/user/template | type: remote | status: success
+```
+
+## Security Best Practices
+
+### For Users
+
+1. **Review post-config tasks**: Always review commands before executing
+2. **Use trusted sources**: Only download templates from known repositories
+3. **Monitor audit logs**: Check `~/.pt/security-audit.log` for suspicious activity
+4. **Update regularly**: Keep `pt-cli` updated for latest security improvements
+
+### For Template Authors
+
+1. **Avoid dangerous commands**: Don't include `sudo`, `rm -rf`, or privilege escalation in templates
+2. **Use safe defaults**: Prefer `npm install` over custom scripts
+3. **Provide clear descriptions**: Explain what each post-config task does
+4. **Test thoroughly**: Verify templates work in isolated environments
+
+## Troubleshooting
+
+### Security Events Not Logging
+
+1. Check write permissions to `~/.pt/` directory
+2. Verify `enableAuditLogging: true` in config
+3. Check for disk space issues
+
+### Commands Blocked Unexpectedly
+
+1. Check if command matches absolute blocklist
+2. Review security policy configuration
+3. Consult audit log for specific reasons
+
+### Remote Template Download Failed
+
+1. Verify URL is in `trustedSources` list
+2. Check network connectivity
+3. Verify file size is under 50MB limit
+4. Check for valid archive format
+
+## Security Policy Reference
+
+| Setting              | Type    | Default | Description                          |
+|---------------------|---------|---------|--------------------------------------|
+| `securityLevel`     | string  | `"warn"`| Security enforcement level           |
+| `trustedSources`    | array   | []      | List of trusted template sources     |
+| `maxExecutionTime`  | number  | 30000   | Max seconds per command (30s default)|
+| `maxCommandsPerRun` | number  | 50      | Rate limit per init session          |
+| `enableAuditLogging`| boolean | true    | Enable security event logging        |

package/doc/testing.md

@@ -8,18 +8,36 @@ The test suite uses Node.js's native test runner (`node:test`) and assertion lib
 
 ## Running Tests
 
+### 0. Security Testing
+
+Security features can be tested by:
+
+1. **Testing command blocks**: Try running templates with dangerous commands like `sudo rm -rf` or `dd`
+2. **Testing remote downloads**: Use untrusted URLs to verify source verification
+3. **Testing rate limiting**: Execute more than 50 commands in a single init session
+4. **Testing timeouts**: Run commands that hang to verify timeout behavior
+5. **Reviewing audit logs**: Check `~/.pt/security-audit.log` for security events
+
+For more details, see the [Security Guide](security.md).
+
 ### 1. Run the Entire Test Suite
+
 To execute all tests:
+
 ```bash
 npm test
 ```
+
 This runs the underlying command:
+
 ```bash
 node --import tsx --test tests/**/*.test.ts
 ```
 
 ### 2. Run Individual Test Files
+
 To run a specific test suite, use `tsx`:
+
 ```bash
 npx tsx --test tests/config.test.ts
 npx tsx --test tests/learn.test.ts
@@ -27,7 +45,9 @@ npx tsx --test tests/substitute.test.ts
 ```
 
 ### 3. Run with Test Coverage
+
 To generate a test coverage report directly in the terminal:
+
 ```bash
 node --experimental-test-coverage --import tsx --test tests/**/*.test.ts
 ```
@@ -42,7 +62,7 @@ When writing new tests, please adhere to these guidelines:
 2. **ESM Imports**: Since this is an ESM (ECMAScript Modules) project, file imports within tests must use the `.js` extension (e.g., `import { learn } from '../src/commands/learnCommand.js';`).
 3. **Environment Isolation**: The configuration path relies on `process.env.HOME`. To prevent tests from polluting your user config directory, override the home directory before importing any CLI files:
    ```typescript
-   const testHome = path.join(process.cwd(), '.test-home-custom');
+   const testHome = path.join(process.cwd(), ".test-home-custom");
    process.env.HOME = testHome;
    ```
 4. **Cleanup**: Always ensure temporary files, workspace directories, and test home directories are deleted after tests complete (e.g., in a `finally` block or `after` hook).

package/doc/usage.md

@@ -22,26 +22,24 @@ pt learn /path/to/PROJECT --name my_template --desc "My new template" --yes
 
 ### Remote Template Learning
 
-`pt learn` supports learning templates directly from a remote Git repository or tarball archive by passing an `http://` or `https://` URL:
+`pt learn` supports learning templates directly from a remote Git repository or tarball archive by passing an `http://` or `https://` URL. **Security is enforced**: only downloads from `trustedSources` (configured in `~/.pt/config.yaml`) are allowed by default. Untrusted sources trigger a warning and require explicit confirmation.
 
 ```bash
 # Learn a template directly from a GitHub repository
 pt learn https://github.com/username/my-template
-
-# Learn a template from a Gitea repository
-pt learn https://gitea.example.com/username/my-template
 ```
 
 #### How it works:
-1. **URL Translation:** If a GitHub or Gitea URL is provided, `pt` automatically translates the repository URL to its corresponding tarball download endpoint (e.g., `/archive/refs/heads/main.tar.gz`).
-2. **Download & Extraction:** The tool downloads the archive into a secure temporary folder and extracts it.
-3. **Template Discovery:** The extracted directory is scanned for metadata (`.pt-template.json`, `template.json`, `.info.md`, `post_config.sh`, `post_config.bat`) and variable placeholders (`{{ var }}`), matching local learn functionality exactly.
-4. **Save Config:** The template config (skeleton structure, files, variables) is saved to the local configuration, pointing to the temporary folder as the `templateRoot`.
 
+1. **URL Translation:** If a GitHub or Gitea URL is provided, `pt` automatically translates the repository URL to its corresponding tarball download endpoint (e.g., `/archive/refs/heads/main.tar.gz`).
+2. **Security Verification:** Downloads are restricted to trusted sources (configured in `~/.pt/config.yaml`). Untrusted sources trigger a warning and require explicit confirmation.
+3. **Download & Extraction:** The tool downloads the archive into a secure temporary folder and extracts it. File size is validated (max 50MB).
+4. **Template Discovery:** The extracted directory is scanned for metadata (`.pt-template.json`, `template.json`, `.info.md`, `post_config.sh`, `post_config.bat`) and variable placeholders (`{{ var }}`), matching local learn functionality exactly.
+5. **Save Config:** The template config (skeleton structure, files, variables) is saved to the local configuration, pointing to the temporary folder as the `templateRoot`.
 
 ### Automatic Variable Detection
 
-During `pt learn` or `pt update`, the tool automatically scans text files at the root and in the first-level subdirectories for variable placeholders using the `{{ variable_name }}` syntax. 
+During `pt learn` or `pt update`, the tool automatically scans text files at the root and in the first-level subdirectories for variable placeholders using the `{{ variable_name }}` syntax.
 
 - **Detection Range:** Root files and 1st-level subfolder files (e.g., `README.md`, `.makerc`, `DOC/closedown.md`).
 - **Registration:** Any detected variables are automatically added to the template's configuration with default prompts (e.g., `Enter variable_name:`).
@@ -141,7 +139,12 @@ The JSON template config file is the recommended way to make a template director
   "name": "my-web-app",
   "description": "A Node.js web application with Express",
   "variables": [
-    { "name": "project_name", "prompt": "Project name:", "default": "my-app", "required": true },
+    {
+      "name": "project_name",
+      "prompt": "Project name:",
+      "default": "my-app",
+      "required": true
+    },
     { "name": "author", "prompt": "Author name:", "default": "" }
   ],
   "folders": [
@@ -149,16 +152,18 @@ The JSON template config file is the recommended way to make a template director
     { "name": "tests", "children": [] }
   ],
   "copy_files": [
-    { "src": "package.json", "dest": "package.json", "substitute_variables": true },
+    {
+      "src": "package.json",
+      "dest": "package.json",
+      "substitute_variables": true
+    },
     { "src": "README.md", "dest": "README.md", "substitute_variables": true }
   ],
   "post_config": [
     { "command": "git init", "description": "Initialize git repository" },
     { "command": "npm install", "description": "Install dependencies" }
   ],
-  "post_copy": [
-    { "src": "bin/start.sh", "dest": "bin/start.sh" }
-  ]
+  "post_copy": [{ "src": "bin/start.sh", "dest": "bin/start.sh" }]
 }
 ```
 
@@ -189,30 +194,39 @@ pt init ./new-project --file .pt-template.json --yes
 For a more portable, text-based approach, you can export and import templates as JSON strings or files.
 
 #### Exporting a Template to JSON
+
 To export an existing template from your configuration as JSON:
+
 ```bash
 pt config <template_name> --json > my_template.json
 ```
 
 #### Importing a Template from JSON
+
 To add a template from a JSON file:
+
 ```bash
 pt add <template_name> --file my_template.json
 ```
 
 Or from a JSON string:
+
 ```bash
 pt add <template_name> '{"description":"My Template","files":{...}}'
 ```
 
 #### Direct JSON Scaffolding (no config registration)
+
 To scaffold a project directly from a JSON file without adding the template to your config:
+
 ```bash
 pt init ./destination --file my_template.json --yes
 ```
 
 #### Exporting Full Config
+
 To see your entire configuration (including all templates) in JSON format:
+
 ```bash
 pt config --json
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@garyr/pt-cli",
-  "version": "0.32.1",
+  "version": "0.36.4",
   "description": "Project Template CLI - Learn structures and initialize projects",
   "main": "dist/index.js",
   "bin": {
@@ -14,9 +14,9 @@
     "test": "node --import tsx --test tests/**/*.test.ts",
     "test:sequential": "node --import tsx --test tests/config.test.ts && node --import tsx --test tests/init.test.ts && node --import tsx --test tests/learn.test.ts && node --import tsx --test tests/substitute.test.ts && node --import tsx --test tests/config-utils.test.ts",
     "prepublishOnly": "npm run build",
-    "build:linux": "bun build ./src/index.ts --compile --target=bun-linux-x64   --outfile ../BUILD/pt-cli/pt-linux",
-    "build:macos": "bun build ./src/index.ts --compile --target=bun-darwin-x64  --outfile ../BUILD/pt-cli/pt-macos",
-    "build:windows": "bun build ./src/index.ts --compile --target=bun-windows-x64 --outfile ../BUILD/pt-cli/pt-win.exe",
+    "build:linux": "bun build ./src/index.ts --compile --minify --target=bun-linux-x64   --outfile ../BUILD/pt-cli/pt-linux",
+    "build:macos": "bun build ./src/index.ts --compile --minify --target=bun-darwin-x64  --outfile ../BUILD/pt-cli/pt-macos",
+    "build:windows": "bun build ./src/index.ts --compile --minify --target=bun-windows-x64 --outfile ../BUILD/pt-cli/pt-win.exe",
     "build:all": "npm run build:linux && npm run build:macos && npm run build:windows"
   },
   "license": "MIT",
@@ -43,4 +43,4 @@
     "tsx": "^4.21.0",
     "typescript": "^5.6.0"
   }
-}
+}

package/skills/agency-pt-operator/SKILL.md

@@ -79,17 +79,25 @@ pt init ./new-project --file my-template.json --yes
 
 ### Round-trip Workflow
 
-The complete portable template workflow:
-1. `pt config my-template --json > .pt-template.json` — export config
-2. Copy `.pt-template.json` into the template source directory
-3. Share the directory (zip, git repo, etc.)
-4. Recipient: `pt learn /path/to/shared-dir --yes` — auto-detects everything
-5. Or scaffold directly without registering: `pt init ./new-project --file .pt-template.json --yes`
+The complete portable template workflow, perfect for sharing:
+
+1. **Create template:** `pt init <template> <dest> --yes --skip-post-config` — creates structure without auto-executing post-config tasks (e.g., `git init`)
+2. **Export config:** `pt config <template> --json > <dest>/.pt-template.json` — exports portable JSON config, required to include variables
+3. **Share directory/JSON:** Share the directory or JSON file
+4. **Recipient:** `pt learn <path> --name <template> --yes` — imports the template
+5. **Or scaffold directly:** `pt init ./new-project --file .pt-template.json --yes`
 
 ### JSON Output for Sharing
 
 You can output a template as JSON for sharing without saving it: `pt learn <source_path> --json`
 
+### Important Notes
+
+- **Never use manual `mkdir`/`cp` steps** — `pt init` already scaffolds directory structures, and manual file copying bypasses template registration
+- **`--skip-post-config` flag** prevents premature task execution during template creation
+- **JSON export captures all template metadata**, variables, and post-config tasks for maximum portability
+- The workflow ensures portability by bundling metadata and files together, allowing recipients to import via `pt learn` without manual directory manipulation
+
 ## Default Post-Config
 
 Default post-config tasks are stored in `~/.pt/config.yaml` under `default_post_config`. They are used as suggestions during `pt learn` to apply to the newly created template. Each task supports:
@@ -128,6 +136,56 @@ Global variables are defined in `~/.pt/config.yaml` under `variables`. They act
 - Atomic saves, backups, and safe initialization logic prevent data loss.
 - Platform-specific post-config scripts (`.sh`/`.bat`) are executed automatically based on the OS.
 
+## Security Configuration
+
+### Security Policy Settings
+
+Security settings are configured in `~/.pt/config.yaml` under the `security` key:
+
+```yaml
+security:
+  securityLevel: "warn"  # "warn" (default) or "strict"
+  trustedSources:
+    - "github.com/garyritchie"
+    - "git.lyonritchie.com"
+    - "github.com/lyonritchie"
+  maxExecutionTime: 30000  # 30 seconds per command
+  maxCommandsPerRun: 50    # rate limit per init session
+  enableAuditLogging: true # write events to security-audit.log
+```
+
+### Security Levels
+
+- **`warn`** (default): Warning-based approach with cancellation prompts
+- **`strict`**: More conservative defaults, enabled by default for new installations
+
+### Trusted Sources
+
+When downloading templates from remote URLs, `pt-cli` verifies the source against the `trustedSources` list. Untrusted sources trigger a warning and require explicit user confirmation before proceeding.
+
+### Command Security
+
+- **Absolute blocks**: Commands like `sudo`, `rm -rf`, `dd` are always blocked
+- **Dangerous commands**: Commands like `curl`, `python`, `chmod` trigger warnings
+- **Rate limiting**: 50 commands per run prevents runaway execution
+- **Execution timeout**: 30 seconds per command prevents hung processes
+
+### Audit Logging
+
+All security events are logged to `~/.pt/security-audit.log` for monitoring and troubleshooting.
+
+## Security Testing
+
+Security features can be tested by:
+
+1. **Testing command blocks**: Try running templates with dangerous commands like `sudo rm -rf` or `dd`
+2. **Testing remote downloads**: Use untrusted URLs to verify source verification
+3. **Testing rate limiting**: Execute more than 50 commands in a single init session
+4. **Testing timeouts**: Run commands that hang to verify timeout behavior
+5. **Reviewing audit logs**: Check `~/.pt/security-audit.log` for security events
+
+For more details, see the [Security Guide](security.md).
+
 ## CLI Reference
 
 | Command | Description |

package/src/commands/defaultPostConfigCommand.ts

@@ -27,6 +27,7 @@ export function defaultPostConfigCommand(options: DefaultPostConfigOptions = {})
 
     console.error('You must provide --json <data> to set the default post-config array.');
   } else {
-    console.log('Current default post-config tasks:', config.default_post_config || []);
+    const tasks = config.default_post_config || [];
+    console.log(JSON.stringify(tasks, null, 2));
   }
 }

package/src/commands/initCommand.ts

@@ -172,26 +172,29 @@ export async function init(targetName: string | undefined, destPath: string | un
       if (fs.existsSync(srcPath)) {
         if (options.dryRun) {
           console.log(chalk.gray(`  [DRY RUN] Would copy ${file.src} → ${file.dest || file.src}`));
-          const ext = path.extname(file.src);
-          if (['.sh', '.py', '.bash', '.bat'].includes(ext)) {
-            console.log(chalk.gray(`  [DRY RUN] Would chmod +x ${file.dest || file.src}`));
-          }
+          console.log(chalk.gray(`  [DRY RUN] Would chmod +x ${file.dest || file.src}`));
           continue;
         }
 
-        const fileContent = fs.readFileSync(srcPath, 'utf-8');
+        let fileContent = fs.readFileSync(srcPath, 'utf-8');
+
+        // Substitute variables in post_copy files if template has variables
+        if (template.variables && template.variables.length > 0) {
+          const { substituteVariables } = await import('../substitute.js');
+          fileContent = substituteVariables(fileContent, variables);
+        }
+
         const destDir = path.dirname(destPath);
         fs.mkdirSync(destDir, { recursive: true });
         fs.writeFileSync(destPath, fileContent);
 
-        // Auto-chmod for executables
-        const ext = path.extname(file.src);
-        if (['.sh', '.py', '.bash', '.bat'].includes(ext)) {
-          try {
-            fs.chmodSync(destPath, 0o755);
-          } catch (e) {
-            // chmod not available (Windows)
-          }
+        // post_copy files are executables by definition — always chmod
+        try {
+          // Check if source had execute permissions, otherwise default to 0o755
+          const srcStat = fs.statSync(srcPath);
+          fs.chmodSync(destPath, srcStat.mode & 0o111 ? srcStat.mode : 0o755);
+        } catch (e) {
+          // chmod not available (Windows)
         }
         console.log(chalk.green("  ✓ " + (file.dest || file.src)));
       } else {
@@ -210,7 +213,40 @@ export async function init(targetName: string | undefined, destPath: string | un
   // Use template post_config tasks
   const allTasks = template.post_config?.filter(t => !t.type || t.type === typeName!) || [];
 
-  if (allTasks.length > 0) {
+  if (allTasks.length > 0 && !options.skipPostConfig) {
+    // SECURITY CHECK: Validate template safety before running post_config tasks
+    const { validateTemplateSecurity } = await import('../safety.js');
+    const { valid, errors, warnings } = validateTemplateSecurity(template);
+    
+    if (!valid) {
+      console.error(chalk.red("\n❌ SECURITY ERROR: Aborting post_config execution due to blocked commands:"));
+      for (const err of errors) {
+        console.error(chalk.red(`   - ${err}`));
+      }
+      process.exit(1);
+    }
+
+    if (warnings.length > 0) {
+      console.warn(chalk.yellow("\n⚠️  SECURITY WARNING: Post-config contains dangerous or suspicious commands:"));
+      for (const warn of warnings) {
+        console.warn(chalk.yellow(`   - ${warn}`));
+      }
+      
+      if (!options.yes) {
+        const { proceed } = await inquirer.prompt({
+          type: 'confirm',
+          name: 'proceed',
+          message: chalk.red('Are you sure you want to run these post-config tasks?'),
+          default: false
+        });
+        if (!proceed) {
+          console.log(chalk.yellow("Post-config tasks aborted by user."));
+          return;
+        }
+      } else {
+        console.warn(chalk.yellow("Proceeding anyway (non-interactive mode with auto-confirm enabled)."));
+      }
+    }
     // Determine which tasks to include
     let selectedTaskNames: string[] = [];
     

package/src/commands/learnCommand.ts

@@ -11,6 +11,7 @@ export interface LearnOptions {
   name?: string;
   desc?: string;
   json?: boolean;
+  allowUntrusted?: boolean;
 }
 
 
@@ -20,7 +21,7 @@ export async function learn(sourcePath: string, updateTemplate: string | null =
   // Phase 1: Remote Check
   if (sourcePath.startsWith('http')) {
     console.log(chalk.cyan(`Downloading remote template from: ${sourcePath}...`));
-    resolvedPath = await downloadAndExtract(sourcePath);
+    resolvedPath = await downloadAndExtract(sourcePath, options.json || false, options.allowUntrusted || false);
   } else {
     resolvedPath = path.resolve(sourcePath);
   }

package/src/commands/securityResponseCommand.ts

@@ -0,0 +1,18 @@
+// pt-cli/src/commands/securityResponseCommand.ts
+// CLI command to handle security responses from GUI
+
+import { handleSecurityResponse } from '../safety.js';
+
+export interface SecurityResponseOptions {
+  response: string;
+}
+
+export async function securityResponseCommand(response: string, options: SecurityResponseOptions = { response: '' }): Promise<void> {
+  const result = await handleSecurityResponse(response);
+  
+  if (result) {
+    console.log('SECURITY_RESPONSE:ALLOWED');
+  } else {
+    console.log('SECURITY_RESPONSE:DENIED');
+  }
+}

package/src/config.ts

@@ -3,6 +3,7 @@ import fs from 'fs';
 import path from 'path';
 import os from 'os';
 import chalk from 'chalk';
+import { SecurityPolicy } from './safety.js';
 
 export function getHomeDir(): string {
   return path.join(os.homedir(), '.pt');
@@ -65,6 +66,7 @@ export interface PtConfig {
   ignore?: string[];  // top-level folder ignore patterns for pt learn
   default_post_config?: PostConfigTask[];  // default post-config tasks applied to all projects
   variables?: TemplateVariable[];         // global variables for substitution
+  security?: SecurityPolicy;  // security policy configuration
 }
 
 export function ensureConfigDir() {
@@ -221,6 +223,25 @@ export function getDefaultPostConfig(config: PtConfig): PostConfigTask[] {
   }));
 }
 
+/**
+ * Get security policy from config or use defaults
+ */
+export function getSecurityPolicy(config: PtConfig): SecurityPolicy {
+  const defaultPolicy: SecurityPolicy = {
+    maxExecutionTime: 30000, // 30 seconds
+    enableAuditLogging: true,
+    trustedSources: [
+      'github.com/garyritchie',
+      'gitea.lyonritchie.com/garyritchie',
+      'github.com/lyonritchie',
+    ],
+    maxCommandsPerRun: 50,
+    securityLevel: 'warn',
+  };
+
+  return config.security || defaultPolicy;
+}
+
 // Default exclusions for template scanning
 export const DEFAULT_EXCLUDES = [
   '.git',