@dinasor/mnemo-cli 0.0.1

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@dinasor/mnemo-cli",
+  "version": "0.0.1",
+  "description": "Mnemo installer CLI for the current project folder.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DiNaSoR/Mnemo.git"
+  },
+  "homepage": "https://github.com/DiNaSoR/Mnemo#readme",
+  "bugs": {
+    "url": "https://github.com/DiNaSoR/Mnemo/issues"
+  },
+  "bin": {
+    "mnemo": "bin/mnemo.js"
+  },
+  "files": [
+    "bin/",
+    "memory.ps1",
+    "memory_mac.sh",
+    "VERSION",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "scripts/memory/installer/**/*.ps1",
+    "scripts/memory/installer/**/*.py",
+    "scripts/memory/installer/**/*.yaml",
+    "scripts/memory/installer/**/*.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/scripts/memory/installer/bootstrap.ps1

@@ -0,0 +1,21 @@
+<#
+bootstrap.ps1 - Dot-sources all Mnemo installer modules in dependency order.
+Call this from memory.ps1 AFTER setting $DryRun, $Force, $EnableVector, $VectorProvider.
+#>
+param(
+  [Parameter(Mandatory=$true)][string]$InstallerRoot
+)
+
+$modulesBase = Join-Path $InstallerRoot "scripts\memory\installer"
+
+# Core layer
+. (Join-Path $modulesBase "core\io.ps1")
+. (Join-Path $modulesBase "core\paths.ps1")
+. (Join-Path $modulesBase "core\bridge.ps1")
+
+# Feature layer
+. (Join-Path $modulesBase "features\memory_scaffold.ps1")
+. (Join-Path $modulesBase "features\vector_setup.ps1")
+. (Join-Path $modulesBase "features\mcp_setup.ps1")
+. (Join-Path $modulesBase "features\hooks_setup.ps1")
+. (Join-Path $modulesBase "features\gitignore_setup.ps1")

package/scripts/memory/installer/core/bridge.ps1

@@ -0,0 +1,285 @@
+<#
+bridge.ps1 - Canonical path bridge helpers for Mnemo.
+Dot-sourced by bootstrap.ps1. Depends on io.ps1 functions.
+#>
+
+function Get-MnemoFullPath {
+  param([Parameter(Mandatory=$true)][string]$Path)
+  return [System.IO.Path]::GetFullPath($Path)
+}
+
+function Test-MnemoPathEqual {
+  param(
+    [Parameter(Mandatory=$true)][string]$A,
+    [Parameter(Mandatory=$true)][string]$B
+  )
+  $aFull = Get-MnemoFullPath -Path $A
+  $bFull = Get-MnemoFullPath -Path $B
+  $comparison = if ([System.Environment]::OSVersion.Platform -eq [System.PlatformID]::Win32NT) {
+    [System.StringComparison]::OrdinalIgnoreCase
+  } else {
+    [System.StringComparison]::Ordinal
+  }
+  return [string]::Equals($aFull, $bFull, $comparison)
+}
+
+function Test-MnemoReparsePoint {
+  param([Parameter(Mandatory=$true)][string]$Path)
+  if (-not (Test-Path -LiteralPath $Path)) { return $false }
+  $item = Get-Item -LiteralPath $Path -Force -ErrorAction SilentlyContinue
+  if ($null -eq $item) { return $false }
+  return (($item.Attributes -band [System.IO.FileAttributes]::ReparsePoint) -ne 0)
+}
+
+function Copy-MnemoDirectoryContent {
+  param(
+    [Parameter(Mandatory=$true)][string]$SourceDir,
+    [Parameter(Mandatory=$true)][string]$TargetDir
+  )
+
+  if (-not (Test-Path -LiteralPath $SourceDir)) { return 0 }
+  New-MnemoDirectory -Path $TargetDir
+
+  $sourceFull = Get-MnemoFullPath -Path $SourceDir
+  $copied = 0
+  $files = Get-ChildItem -LiteralPath $SourceDir -Recurse -Force -File -ErrorAction SilentlyContinue
+  foreach ($src in $files) {
+    $relative = $src.FullName.Substring($sourceFull.Length).TrimStart('\', '/')
+    if ([string]::IsNullOrWhiteSpace($relative)) { continue }
+    $dst = Join-Path $TargetDir $relative
+    $dstDir = Split-Path -Parent $dst
+    if ($dstDir -and -not (Test-Path -LiteralPath $dstDir)) {
+      if ($script:DryRun) {
+        Write-Host "[DRY RUN] WOULD CREATE DIR: $dstDir" -ForegroundColor DarkCyan
+      } else {
+        New-Item -ItemType Directory -Force -Path $dstDir | Out-Null
+      }
+    }
+
+    $needsCopy = $true
+    if (Test-Path -LiteralPath $dst) {
+      $dstInfo = Get-Item -LiteralPath $dst -Force
+      if (($dstInfo.Length -eq $src.Length) -and ($dstInfo.LastWriteTimeUtc -ge $src.LastWriteTimeUtc)) {
+        $needsCopy = $false
+      }
+    }
+    if (-not $needsCopy) { continue }
+
+    if ($script:DryRun) {
+      Write-Host "[DRY RUN] WOULD COPY: $($src.FullName) -> $dst" -ForegroundColor DarkCyan
+      $copied++
+      continue
+    }
+    Copy-Item -LiteralPath $src.FullName -Destination $dst -Force
+    $copied++
+  }
+  return $copied
+}
+
+function New-MnemoDirectoryLink {
+  param(
+    [Parameter(Mandatory=$true)][string]$LinkPath,
+    [Parameter(Mandatory=$true)][string]$TargetPath
+  )
+
+  $parent = Split-Path -Parent $LinkPath
+  if ($parent -and -not (Test-Path -LiteralPath $parent)) {
+    New-MnemoDirectory -Path $parent
+  }
+
+  if ($script:DryRun) {
+    Write-Host "[DRY RUN] WOULD LINK DIR: $LinkPath -> $TargetPath" -ForegroundColor DarkCyan
+    return "dry-run-link"
+  }
+
+  try {
+    New-Item -ItemType SymbolicLink -Path $LinkPath -Target $TargetPath -Force -ErrorAction Stop | Out-Null
+    return "symlink"
+  } catch {}
+
+  if ([System.Environment]::OSVersion.Platform -eq [System.PlatformID]::Win32NT) {
+    try {
+      $null = & cmd /c "mklink /J ""$LinkPath"" ""$TargetPath""" 2>$null
+      if ($LASTEXITCODE -eq 0 -and (Test-Path -LiteralPath $LinkPath)) {
+        return "junction"
+      }
+    } catch {}
+  }
+  return $null
+}
+
+function New-MnemoFileLink {
+  param(
+    [Parameter(Mandatory=$true)][string]$LinkPath,
+    [Parameter(Mandatory=$true)][string]$TargetPath
+  )
+
+  $parent = Split-Path -Parent $LinkPath
+  if ($parent -and -not (Test-Path -LiteralPath $parent)) {
+    New-MnemoDirectory -Path $parent
+  }
+
+  if ($script:DryRun) {
+    Write-Host "[DRY RUN] WOULD LINK FILE: $LinkPath -> $TargetPath" -ForegroundColor DarkCyan
+    return "dry-run-link"
+  }
+
+  try {
+    New-Item -ItemType SymbolicLink -Path $LinkPath -Target $TargetPath -Force -ErrorAction Stop | Out-Null
+    return "symlink"
+  } catch {}
+
+  try {
+    New-Item -ItemType HardLink -Path $LinkPath -Target $TargetPath -Force -ErrorAction Stop | Out-Null
+    return "hardlink"
+  } catch {}
+
+  return $null
+}
+
+function Ensure-MnemoDirectoryBridge {
+  param(
+    [Parameter(Mandatory=$true)][string]$CanonicalDir,
+    [Parameter(Mandatory=$true)][string]$BridgeDir
+  )
+
+  New-MnemoDirectory -Path $CanonicalDir
+
+  if (-not (Test-Path -LiteralPath $BridgeDir)) {
+    $mode = New-MnemoDirectoryLink -LinkPath $BridgeDir -TargetPath $CanonicalDir
+    if ($mode) {
+      Write-Host "BRIDGE ($mode): $BridgeDir -> $CanonicalDir" -ForegroundColor Green
+      return $mode
+    }
+
+    New-MnemoDirectory -Path $BridgeDir
+    $copied = Copy-MnemoDirectoryContent -SourceDir $CanonicalDir -TargetDir $BridgeDir
+    Write-Host "BRIDGE (mirror): $BridgeDir <-> $CanonicalDir (copied $copied files)" -ForegroundColor Yellow
+    return "mirror"
+  }
+
+  $bridgeResolved = (Resolve-Path -LiteralPath $BridgeDir -ErrorAction SilentlyContinue).Path
+  if ($bridgeResolved -and (Test-MnemoPathEqual -A $bridgeResolved -B $CanonicalDir)) {
+    Write-Host "BRIDGE (linked): $BridgeDir -> $CanonicalDir" -ForegroundColor DarkGreen
+    return "linked"
+  }
+
+  if (Test-MnemoReparsePoint -Path $BridgeDir) {
+    if ($script:DryRun) {
+      Write-Host "[DRY RUN] WOULD REPAIR BRIDGE: $BridgeDir -> $CanonicalDir" -ForegroundColor DarkCyan
+      return "repair-dry-run"
+    }
+    Remove-Item -LiteralPath $BridgeDir -Recurse -Force -ErrorAction SilentlyContinue
+    $mode = New-MnemoDirectoryLink -LinkPath $BridgeDir -TargetPath $CanonicalDir
+    if ($mode) {
+      Write-Host "BRIDGE (repaired-$mode): $BridgeDir -> $CanonicalDir" -ForegroundColor Green
+      return "repaired-$mode"
+    }
+  }
+
+  $toCanonical = Copy-MnemoDirectoryContent -SourceDir $BridgeDir -TargetDir $CanonicalDir
+  $toBridge = Copy-MnemoDirectoryContent -SourceDir $CanonicalDir -TargetDir $BridgeDir
+  Write-Host "BRIDGE (mirror): $BridgeDir <-> $CanonicalDir (sync $toCanonical/$toBridge files)" -ForegroundColor Yellow
+  return "mirror"
+}
+
+function Ensure-MnemoFileBridge {
+  param(
+    [Parameter(Mandatory=$true)][string]$CanonicalPath,
+    [Parameter(Mandatory=$true)][string]$BridgePath
+  )
+
+  $canonicalDir = Split-Path -Parent $CanonicalPath
+  if ($canonicalDir) { New-MnemoDirectory -Path $canonicalDir }
+
+  if ((-not (Test-Path -LiteralPath $CanonicalPath)) -and (Test-Path -LiteralPath $BridgePath)) {
+    if ($script:DryRun) {
+      Write-Host "[DRY RUN] WOULD COPY: $BridgePath -> $CanonicalPath" -ForegroundColor DarkCyan
+    } else {
+      Copy-Item -LiteralPath $BridgePath -Destination $CanonicalPath -Force
+    }
+  }
+
+  if (-not (Test-Path -LiteralPath $CanonicalPath)) {
+    return "missing-canonical"
+  }
+
+  if (-not (Test-Path -LiteralPath $BridgePath)) {
+    $mode = New-MnemoFileLink -LinkPath $BridgePath -TargetPath $CanonicalPath
+    if ($mode) {
+      Write-Host "BRIDGE ($mode): $BridgePath -> $CanonicalPath" -ForegroundColor Green
+      return $mode
+    }
+    if ($script:DryRun) {
+      Write-Host "[DRY RUN] WOULD COPY: $CanonicalPath -> $BridgePath" -ForegroundColor DarkCyan
+      return "mirror-dry-run"
+    }
+    Copy-Item -LiteralPath $CanonicalPath -Destination $BridgePath -Force
+    Write-Host "BRIDGE (mirror): $BridgePath <- $CanonicalPath" -ForegroundColor Yellow
+    return "mirror"
+  }
+
+  $bridgeItem = Get-Item -LiteralPath $BridgePath -Force -ErrorAction SilentlyContinue
+  if ($null -ne $bridgeItem -and ($bridgeItem.PSObject.Properties.Name -contains "LinkType") -and $bridgeItem.LinkType) {
+    $targets = @()
+    if ($bridgeItem.PSObject.Properties.Name -contains "Target" -and $bridgeItem.Target) {
+      $targets = @($bridgeItem.Target)
+    }
+    foreach ($target in $targets) {
+      if ($target -and (Test-MnemoPathEqual -A ([string]$target) -B $CanonicalPath)) {
+        Write-Host "BRIDGE (linked): $BridgePath -> $CanonicalPath" -ForegroundColor DarkGreen
+        return "linked"
+      }
+    }
+  }
+
+  $bridgeResolved = (Resolve-Path -LiteralPath $BridgePath -ErrorAction SilentlyContinue).Path
+  if ($bridgeResolved -and (Test-MnemoPathEqual -A $bridgeResolved -B $CanonicalPath)) {
+    Write-Host "BRIDGE (linked): $BridgePath -> $CanonicalPath" -ForegroundColor DarkGreen
+    return "linked"
+  }
+
+  if (Test-MnemoReparsePoint -Path $BridgePath) {
+    if ($script:DryRun) {
+      Write-Host "[DRY RUN] WOULD REPAIR FILE BRIDGE: $BridgePath -> $CanonicalPath" -ForegroundColor DarkCyan
+      return "repair-dry-run"
+    }
+    Remove-Item -LiteralPath $BridgePath -Force -ErrorAction SilentlyContinue
+    $mode = New-MnemoFileLink -LinkPath $BridgePath -TargetPath $CanonicalPath
+    if ($mode) {
+      Write-Host "BRIDGE (repaired-$mode): $BridgePath -> $CanonicalPath" -ForegroundColor Green
+      return "repaired-$mode"
+    }
+  }
+
+  if ($script:DryRun) {
+    Write-Host "[DRY RUN] WOULD MIRROR FILE: $CanonicalPath <-> $BridgePath" -ForegroundColor DarkCyan
+    return "mirror-dry-run"
+  }
+
+  $canonicalInfo = Get-Item -LiteralPath $CanonicalPath -Force
+  $bridgeInfo = Get-Item -LiteralPath $BridgePath -Force
+  if ($bridgeInfo.LastWriteTimeUtc -gt $canonicalInfo.LastWriteTimeUtc) {
+    Copy-Item -LiteralPath $BridgePath -Destination $CanonicalPath -Force
+  }
+  Copy-Item -LiteralPath $CanonicalPath -Destination $BridgePath -Force
+  Write-Host "BRIDGE (mirror): $BridgePath <-> $CanonicalPath" -ForegroundColor Yellow
+  return "mirror"
+}
+
+function Ensure-MnemoCanonicalBridges {
+  param(
+    [Parameter(Mandatory=$true)][hashtable]$Ctx
+  )
+
+  # Directory bridges
+  $null = Ensure-MnemoDirectoryBridge -CanonicalDir $Ctx.MemoryDir -BridgeDir $Ctx.CursorMemoryDir
+  $null = Ensure-MnemoDirectoryBridge -CanonicalDir $Ctx.RulesDir -BridgeDir $Ctx.CursorRulesDir
+  $null = Ensure-MnemoDirectoryBridge -CanonicalDir $Ctx.MnemoRulesAgentDir -BridgeDir $Ctx.AgentRulesDir
+
+  # File bridge for Cursor MCP config (if either side exists).
+  if ((Test-Path -LiteralPath $Ctx.MnemoCursorMcpPath) -or (Test-Path -LiteralPath $Ctx.CursorMcpPath)) {
+    $null = Ensure-MnemoFileBridge -CanonicalPath $Ctx.MnemoCursorMcpPath -BridgePath $Ctx.CursorMcpPath
+  }
+}
+

package/scripts/memory/installer/core/io.ps1

@@ -0,0 +1,110 @@
+<#
+io.ps1 - Core I/O utilities for Mnemo installer.
+Dot-sourced by bootstrap.ps1. Requires $DryRun to be set in caller scope.
+#>
+
+function New-MnemoDirectory {
+  param([Parameter(Mandatory=$true)][string]$Path)
+  if (!(Test-Path $Path)) {
+    if ($script:DryRun) {
+      Write-Host "[DRY RUN] WOULD CREATE DIR: $Path" -ForegroundColor DarkCyan
+      return
+    }
+    New-Item -ItemType Directory -Force -Path $Path | Out-Null
+    Write-Host "DIR: $Path" -ForegroundColor Green
+  }
+}
+
+function Write-MnemoFile {
+  param(
+    [Parameter(Mandatory=$true)][string]$Path,
+    [Parameter(Mandatory=$true)][string]$Content,
+    [ValidateSet("CRLF","LF")][string]$LineEndings = "CRLF",
+    [switch]$ForceWrite
+  )
+
+  $dir = Split-Path -Parent $Path
+  if ($dir -and !(Test-Path $dir)) {
+    if ($script:DryRun) { Write-Host "[DRY RUN] WOULD CREATE DIR: $dir" -ForegroundColor DarkCyan; return }
+    New-Item -ItemType Directory -Force -Path $dir | Out-Null
+  }
+
+  if ((Test-Path $Path) -and (-not $ForceWrite)) {
+    Write-Host "SKIP (exists): $Path" -ForegroundColor DarkYellow
+    return
+  }
+
+  if ($script:DryRun) {
+    Write-Host "[DRY RUN] WOULD WRITE: $Path" -ForegroundColor DarkCyan
+    return
+  }
+
+  $normalized = if ($LineEndings -eq "CRLF") {
+    ($Content -replace "`r?`n", "`r`n")
+  } else {
+    ($Content -replace "`r?`n", "`n")
+  }
+
+  $enc = New-Object System.Text.UTF8Encoding($false)
+  [System.IO.File]::WriteAllText($Path, $normalized, $enc)
+  Write-Host "WROTE: $Path" -ForegroundColor Green
+}
+
+function Install-TemplateFile {
+  <#
+  .SYNOPSIS
+  Copies a template file from the installer templates directory to the target path.
+  #>
+  param(
+    [Parameter(Mandatory=$true)][string]$TemplateName,
+    [Parameter(Mandatory=$true)][string]$DestPath,
+    [Parameter(Mandatory=$true)][string]$InstallerRoot,
+    [ValidateSet("CRLF","LF")][string]$LineEndings = "CRLF",
+    [switch]$ForceWrite
+  )
+
+  $templatePath = Join-Path $InstallerRoot "scripts\memory\installer\templates\$TemplateName"
+  if (-not (Test-Path $templatePath)) {
+    Write-Host "WARNING: Template not found: $templatePath" -ForegroundColor Yellow
+    return
+  }
+
+  $content = Get-Content -Raw -Encoding UTF8 $templatePath
+  if ($content -and $content.Length -gt 0 -and [int]$content[0] -eq 0xFEFF) {
+    $content = $content.Substring(1)
+  }
+
+  Write-MnemoFile -Path $DestPath -Content $content -LineEndings $LineEndings -ForceWrite:$ForceWrite
+}
+
+function Read-Utf8NoBom {
+  param([Parameter(Mandatory=$true)][string]$Path)
+  $raw = Get-Content -Raw -Encoding UTF8 $Path
+  if ($raw -and $raw.Length -gt 0 -and [int]$raw[0] -eq 0xFEFF) { $raw = $raw.Substring(1) }
+  return $raw
+}
+
+function Test-MnemoTokenBudget {
+  param(
+    [Parameter(Mandatory=$true)][hashtable]$Ctx
+  )
+  $alwaysRead = @(
+    (Join-Path $Ctx.MemoryDir "hot-rules.md"),
+    (Join-Path $Ctx.MemoryDir "active-context.md"),
+    (Join-Path $Ctx.MemoryDir "memo.md")
+  )
+  $totalChars = 0
+  foreach ($p in $alwaysRead) {
+    if (Test-Path $p) {
+      $t = Get-Content -Raw -ErrorAction SilentlyContinue $p
+      if ($t) { $totalChars += $t.Length }
+    }
+  }
+  $estimatedTokens = [math]::Round($totalChars / 4)
+  Write-Host ""
+  if ($totalChars -gt 8000) {
+    Write-Host "WARNING: Always-read layer is $totalChars chars (~$estimatedTokens tokens)." -ForegroundColor Yellow
+  } else {
+    Write-Host "Always-read layer: $totalChars chars (~$estimatedTokens tokens) - Healthy" -ForegroundColor Green
+  }
+}

package/scripts/memory/installer/core/paths.ps1

@@ -0,0 +1,83 @@
+<#
+paths.ps1 - Path resolution for Mnemo installer.
+Dot-sourced by bootstrap.ps1.
+#>
+
+function Initialize-MnemoPaths {
+  param(
+    [Parameter(Mandatory=$true)][string]$RepoRoot
+  )
+
+  # Canonical Mnemo identity root
+  $MnemoDir               = Join-Path $RepoRoot ".mnemo"
+  $MnemoMemoryDir         = Join-Path $MnemoDir "memory"
+  $MnemoRulesDir          = Join-Path $MnemoDir "rules"
+  $MnemoRulesCursorDir    = Join-Path $MnemoRulesDir "cursor"
+  $MnemoRulesAgentDir     = Join-Path $MnemoRulesDir "agent"
+  $MnemoMcpDir            = Join-Path $MnemoDir "mcp"
+  $MnemoCursorMcpPath     = Join-Path $MnemoMcpDir "cursor.mcp.json"
+
+  # IDE bridge targets
+  $CursorDir              = Join-Path $RepoRoot ".cursor"
+  $CursorMemoryDir        = Join-Path $CursorDir "memory"
+  $CursorRulesDir         = Join-Path $CursorDir "rules"
+  $CursorMcpPath          = Join-Path $CursorDir "mcp.json"
+  $AgentDir               = Join-Path $RepoRoot ".agent"
+  $AgentRulesDir          = Join-Path $AgentDir "rules"
+
+  # Backward-compatible aliases used by existing feature modules.
+  # During migration these point to canonical .mnemo locations.
+  $MemoryDir      = $MnemoMemoryDir
+  $RulesDir       = $MnemoRulesCursorDir
+  $JournalDir     = Join-Path $MemoryDir "journal"
+  $DigestsDir     = Join-Path $MemoryDir "digests"
+  $AdrDir         = Join-Path $MemoryDir "adr"
+  $LessonsDir     = Join-Path $MemoryDir "lessons"
+  $TemplatesDir   = Join-Path $MemoryDir "templates"
+  $ScriptsDir     = Join-Path $RepoRoot "scripts"
+  $MemScripts     = Join-Path $ScriptsDir "memory"
+  $AutonomyDir    = Join-Path $MemScripts "autonomy"
+  $GitDir         = Join-Path $RepoRoot ".git"
+  $GitHooksDir    = Join-Path $GitDir "hooks"
+  $PortableHooksDir = Join-Path $RepoRoot ".githooks"
+
+  $AllDirs = @(
+    $MnemoDir, $MnemoMemoryDir, $MnemoRulesDir, $MnemoRulesCursorDir, $MnemoRulesAgentDir,
+    $MnemoMcpDir,
+    $CursorDir, $AgentDir,
+    $MemoryDir, $RulesDir, $JournalDir, $DigestsDir, $AdrDir, $LessonsDir, $TemplatesDir,
+    $ScriptsDir, $MemScripts, $AutonomyDir, $PortableHooksDir
+  )
+  $AllDirs = $AllDirs | Select-Object -Unique
+
+  return @{
+    RepoRoot         = $RepoRoot
+    MnemoDir         = $MnemoDir
+    MnemoMemoryDir   = $MnemoMemoryDir
+    MnemoRulesDir    = $MnemoRulesDir
+    MnemoRulesCursorDir = $MnemoRulesCursorDir
+    MnemoRulesAgentDir  = $MnemoRulesAgentDir
+    MnemoMcpDir      = $MnemoMcpDir
+    MnemoCursorMcpPath = $MnemoCursorMcpPath
+    CursorDir        = $CursorDir
+    CursorMemoryDir  = $CursorMemoryDir
+    CursorRulesDir   = $CursorRulesDir
+    CursorMcpPath    = $CursorMcpPath
+    AgentDir         = $AgentDir
+    MemoryDir        = $MemoryDir
+    RulesDir         = $RulesDir
+    JournalDir       = $JournalDir
+    DigestsDir       = $DigestsDir
+    AdrDir           = $AdrDir
+    LessonsDir       = $LessonsDir
+    TemplatesDir     = $TemplatesDir
+    ScriptsDir       = $ScriptsDir
+    MemScripts       = $MemScripts
+    AutonomyDir      = $AutonomyDir
+    GitDir           = $GitDir
+    GitHooksDir      = $GitHooksDir
+    PortableHooksDir = $PortableHooksDir
+    AgentRulesDir    = $AgentRulesDir
+    AllDirs          = $AllDirs
+  }
+}

package/scripts/memory/installer/features/gitignore_setup.ps1

@@ -0,0 +1,80 @@
+<#
+gitignore_setup.ps1 - Managed .gitignore block for Mnemo generated artifacts.
+Dot-sourced by bootstrap.ps1.
+#>
+
+function Update-MnemoGitignore {
+  param(
+    [Parameter(Mandatory=$true)][hashtable]$Ctx,
+    [switch]$EnableVector
+  )
+
+  $giPath = Join-Path $Ctx.RepoRoot ".gitignore"
+  $giBeginMarker = "# >>> Mnemo (generated) - do not edit this block manually <<<"
+  $giEndMarker   = "# <<< Mnemo (generated) >>>"
+
+  $ignoreLines = @(
+    ".mnemo/memory/memory.sqlite",
+    ".cursor/memory/memory.sqlite",
+    ".mnemo/mcp/cursor.mcp.json",
+    ".cursor/mcp.json"
+  )
+  if ($EnableVector) {
+    $ignoreLines += @(
+      ".mnemo/memory/mnemo_vector.sqlite",
+      ".mnemo/memory/mnemo_vector.sqlite-journal",
+      ".mnemo/memory/mnemo_vector.sqlite-wal",
+      ".mnemo/memory/mnemo_vector.sqlite-shm",
+      ".mnemo/memory/.sync.lock",
+      ".mnemo/memory/.autonomy/",
+      ".cursor/memory/mnemo_vector.sqlite",
+      ".cursor/memory/mnemo_vector.sqlite-journal",
+      ".cursor/memory/mnemo_vector.sqlite-wal",
+      ".cursor/memory/mnemo_vector.sqlite-shm",
+      ".cursor/memory/.sync.lock",
+      ".cursor/memory/.autonomy/"
+    )
+  }
+
+  $giLineEndings = "CRLF"
+  $giContent = ""
+  if (Test-Path $giPath) {
+    $giContent = Get-Content -Raw -Encoding UTF8 -ErrorAction SilentlyContinue $giPath
+    if ($null -eq $giContent) { $giContent = "" }
+    if ($giContent.Length -gt 0 -and [int]$giContent[0] -eq 0xFEFF) { $giContent = $giContent.Substring(1) }
+    $giLineEndings = if ($giContent -match "`r`n") { "CRLF" } else { "LF" }
+  }
+
+  $newBlock = $giBeginMarker + "`n" + ($ignoreLines -join "`n") + "`n" + $giEndMarker
+
+  if ($script:DryRun) {
+    Write-Host "[DRY RUN] WOULD UPDATE: $giPath (managed Mnemo block)" -ForegroundColor DarkCyan
+    return
+  }
+
+  $beginEsc = [regex]::Escape($giBeginMarker)
+  $endEsc   = [regex]::Escape($giEndMarker)
+  $blockPattern = "(?s)$beginEsc.*?$endEsc"
+
+  if ($giContent -match $blockPattern) {
+    $newContent = [regex]::Replace($giContent, $blockPattern, $newBlock.Replace('$', '$$'))
+    $existingNorm = $giContent -replace "`r?`n", "`n"
+    $newNorm      = $newContent -replace "`r?`n", "`n"
+    if ($newNorm -ne $existingNorm) {
+      $enc = New-Object System.Text.UTF8Encoding($false)
+      $normalized = if ($giLineEndings -eq "CRLF") { $newContent -replace "`r?`n", "`r`n" } else { $newContent -replace "`r?`n", "`n" }
+      [System.IO.File]::WriteAllText($giPath, $normalized, $enc)
+      Write-Host "WROTE: $giPath (updated Mnemo managed block)" -ForegroundColor Green
+    } else {
+      Write-Host "SKIP (exists): $giPath (Mnemo managed block unchanged)" -ForegroundColor DarkYellow
+    }
+  } else {
+    $trimmed = $giContent.TrimEnd("`r", "`n")
+    $sep = if ($trimmed.Length -gt 0) { "`n`n" } else { "" }
+    $newContent = $trimmed + $sep + $newBlock + "`n"
+    $enc = New-Object System.Text.UTF8Encoding($false)
+    $normalized = if ($giLineEndings -eq "CRLF") { $newContent -replace "`r?`n", "`r`n" } else { $newContent -replace "`r?`n", "`n" }
+    [System.IO.File]::WriteAllText($giPath, $normalized, $enc)
+    Write-Host "WROTE: $giPath (added Mnemo managed block)" -ForegroundColor Green
+  }
+}