Full Code of vinilana/ai-coders-context for AI

gitextract__l45jdix/

├── .context/
│   ├── agents/
│   │   ├── README.md
│   │   ├── bug-fixer.md
│   │   ├── code-reviewer.md
│   │   ├── documentation-writer.md
│   │   ├── feature-developer.md
│   │   ├── performance-optimizer.md
│   │   ├── refactoring-specialist.md
│   │   └── test-writer.md
│   ├── docs/
│   │   ├── README.md
│   │   ├── codebase-map.json
│   │   ├── development-workflow.md
│   │   ├── harness-roadmap.md
│   │   ├── harness-split-foundation.md
│   │   ├── project-overview.md
│   │   ├── qa/
│   │   │   ├── README.md
│   │   │   ├── error-handling.md
│   │   │   ├── getting-started.md
│   │   │   └── project-structure.md
│   │   ├── testing-strategy.md
│   │   └── tooling.md
│   └── skills/
│       ├── README.md
│       ├── api-design/
│       │   └── SKILL.md
│       ├── bug-investigation/
│       │   └── SKILL.md
│       ├── code-review/
│       │   └── SKILL.md
│       ├── commit-message/
│       │   └── SKILL.md
│       ├── documentation/
│       │   └── SKILL.md
│       ├── feature-breakdown/
│       │   └── SKILL.md
│       ├── pr-review/
│       │   └── SKILL.md
│       ├── refactoring/
│       │   └── SKILL.md
│       ├── security-audit/
│       │   └── SKILL.md
│       └── test-generation/
│           └── SKILL.md
├── .env.example
├── .github/
│   ├── PULL_REQUEST_BODY.md
│   └── workflows/
│       ├── ci.yml
│       └── release.yml
├── .gitignore
├── .npmignore
├── AGENTS.md
├── ARCHITECTURE.md
├── CHANGELOG.md
├── CLAUDE.md
├── CONTRIBUTING.md
├── CONVENTIONS.md
├── LICENSE
├── README.md
├── docs/
│   ├── CONTEXT-WORKFLOW-HARNESS-CLI-PTBR.md
│   └── GUIDE.md
├── example-documentation.ts
├── jest.config.js
├── package.json
├── prompts/
│   ├── update_plan_prompt.md
│   └── update_scaffold_prompt.md
├── scripts/
│   ├── build-package-bundles.js
│   ├── release-packages.js
│   ├── smoke-package-bundles.js
│   └── test-mcp.js
├── src/
│   ├── cli/
│   │   ├── index.test.ts
│   │   └── index.ts
│   ├── cli.test.ts
│   ├── generators/
│   │   ├── agents/
│   │   │   ├── agentConfig.ts
│   │   │   ├── agentGenerator.test.ts
│   │   │   ├── agentGenerator.ts
│   │   │   ├── agentTypes.ts
│   │   │   ├── index.ts
│   │   │   └── templates/
│   │   │       ├── index.ts
│   │   │       ├── indexTemplate.ts
│   │   │       └── types.ts
│   │   ├── documentation/
│   │   │   ├── codebaseMapGenerator.ts
│   │   │   ├── documentationGenerator.test.ts
│   │   │   ├── documentationGenerator.ts
│   │   │   ├── guideRegistry.ts
│   │   │   ├── index.ts
│   │   │   └── templates/
│   │   │       ├── common.ts
│   │   │       ├── index.ts
│   │   │       ├── indexTemplate.ts
│   │   │       └── types.ts
│   │   ├── plans/
│   │   │   ├── index.ts
│   │   │   ├── planGenerator.test.ts
│   │   │   ├── planGenerator.ts
│   │   │   └── templates/
│   │   │       ├── indexTemplate.ts
│   │   │       ├── planTemplate.ts
│   │   │       └── types.ts
│   │   ├── shared/
│   │   │   ├── contextGenerator.ts
│   │   │   ├── directoryTemplateHelpers.ts
│   │   │   ├── generatorUtils.ts
│   │   │   ├── index.ts
│   │   │   ├── scaffoldStructures.ts
│   │   │   └── structures/
│   │   │       ├── agents/
│   │   │       │   ├── definitions.ts
│   │   │       │   ├── factory.ts
│   │   │       │   └── index.ts
│   │   │       ├── documentation/
│   │   │       │   ├── apiReference.ts
│   │   │       │   ├── architecture.ts
│   │   │       │   ├── dataFlow.ts
│   │   │       │   ├── glossary.ts
│   │   │       │   ├── index.ts
│   │   │       │   ├── migration.ts
│   │   │       │   ├── onboarding.ts
│   │   │       │   ├── projectOverview.ts
│   │   │       │   ├── security.ts
│   │   │       │   ├── testing.ts
│   │   │       │   ├── tooling.ts
│   │   │       │   ├── troubleshooting.ts
│   │   │       │   └── workflow.ts
│   │   │       ├── index.ts
│   │   │       ├── plans/
│   │   │       │   ├── index.ts
│   │   │       │   └── planStructure.ts
│   │   │       ├── registry.ts
│   │   │       ├── serialization.ts
│   │   │       ├── skills/
│   │   │       │   ├── definitions.ts
│   │   │       │   ├── factory.ts
│   │   │       │   └── index.ts
│   │   │       ├── types.ts
│   │   │       └── validation.ts
│   │   └── skills/
│   │       ├── index.ts
│   │       ├── skillGenerator.test.ts
│   │       ├── skillGenerator.ts
│   │       └── templates/
│   │           ├── indexTemplate.ts
│   │           └── skillTemplate.ts
│   ├── harness/
│   │   ├── index.test.ts
│   │   └── index.ts
│   ├── index.ts
│   ├── mcp/
│   │   ├── bin.test.ts
│   │   ├── bin.ts
│   │   ├── index.test.ts
│   │   └── index.ts
│   ├── prompts/
│   │   └── defaults.ts
│   ├── services/
│   │   ├── autoFill/
│   │   │   ├── autoFillService.ts
│   │   │   └── index.ts
│   │   ├── cli/
│   │   │   ├── index.ts
│   │   │   ├── mcpInstallService.test.ts
│   │   │   ├── mcpInstallService.ts
│   │   │   └── stateDetector.ts
│   │   ├── export/
│   │   │   ├── contextExportService.ts
│   │   │   ├── exportRulesService.ts
│   │   │   ├── index.ts
│   │   │   ├── skillExportService.test.ts
│   │   │   └── skillExportService.ts
│   │   ├── harness/
│   │   │   ├── agentsService.ts
│   │   │   ├── contextService.ts
│   │   │   ├── contextTools.test.ts
│   │   │   ├── contextTools.ts
│   │   │   ├── datasetService.test.ts
│   │   │   ├── datasetService.ts
│   │   │   ├── executionService.test.ts
│   │   │   ├── executionService.ts
│   │   │   ├── index.ts
│   │   │   ├── plansService.ts
│   │   │   ├── policyService.test.ts
│   │   │   ├── policyService.ts
│   │   │   ├── replayService.test.ts
│   │   │   ├── replayService.ts
│   │   │   ├── runtimeStateService.test.ts
│   │   │   ├── runtimeStateService.ts
│   │   │   ├── sensorCatalogService.ts
│   │   │   ├── sensorsService.test.ts
│   │   │   ├── sensorsService.ts
│   │   │   ├── skillsService.ts
│   │   │   ├── taskContractsService.test.ts
│   │   │   ├── taskContractsService.ts
│   │   │   └── workflowStateService.ts
│   │   ├── import/
│   │   │   ├── agentsDetector.ts
│   │   │   ├── importAgentsService.ts
│   │   │   ├── importRulesService.ts
│   │   │   ├── index.ts
│   │   │   ├── presets.ts
│   │   │   ├── rulesDetector.ts
│   │   │   └── types.ts
│   │   ├── mcp/
│   │   │   ├── README.md
│   │   │   ├── actionLogger.test.ts
│   │   │   ├── actionLogger.ts
│   │   │   ├── gateway/
│   │   │   │   ├── agent.ts
│   │   │   │   ├── context.test.ts
│   │   │   │   ├── context.ts
│   │   │   │   ├── explore.ts
│   │   │   │   ├── harness.test.ts
│   │   │   │   ├── harness.ts
│   │   │   │   ├── index.ts
│   │   │   │   ├── metrics.test.ts
│   │   │   │   ├── metrics.ts
│   │   │   │   ├── plan.ts
│   │   │   │   ├── response.ts
│   │   │   │   ├── shared.ts
│   │   │   │   ├── skill.ts
│   │   │   │   ├── sync.ts
│   │   │   │   ├── types.ts
│   │   │   │   ├── workflowAdvance.ts
│   │   │   │   ├── workflowInit.ts
│   │   │   │   ├── workflowManage.test.ts
│   │   │   │   ├── workflowManage.ts
│   │   │   │   ├── workflowStatus.test.ts
│   │   │   │   └── workflowStatus.ts
│   │   │   ├── gatewayTools.ts
│   │   │   ├── index.ts
│   │   │   ├── mcpInstallService.ts
│   │   │   ├── mcpServer.test.ts
│   │   │   └── mcpServer.ts
│   │   ├── qa/
│   │   │   ├── index.ts
│   │   │   ├── patternInferer.ts
│   │   │   ├── qaService.ts
│   │   │   └── topicDetector.ts
│   │   ├── quickSync/
│   │   │   ├── index.ts
│   │   │   └── quickSyncService.ts
│   │   ├── report/
│   │   │   ├── index.ts
│   │   │   └── reportService.ts
│   │   ├── reverseSync/
│   │   │   ├── importSkillsService.ts
│   │   │   ├── index.ts
│   │   │   ├── presets.ts
│   │   │   ├── reverseQuickSyncService.ts
│   │   │   ├── skillsDetector.ts
│   │   │   ├── toolDetector.ts
│   │   │   └── types.ts
│   │   ├── semantic/
│   │   │   ├── codebaseAnalyzer.test.ts
│   │   │   ├── codebaseAnalyzer.ts
│   │   │   ├── contextBuilder.ts
│   │   │   ├── contextCache.test.ts
│   │   │   ├── contextCache.ts
│   │   │   ├── index.ts
│   │   │   ├── lsp/
│   │   │   │   ├── index.ts
│   │   │   │   └── lspLayer.ts
│   │   │   ├── semanticSnapshotService.test.ts
│   │   │   ├── semanticSnapshotService.ts
│   │   │   ├── treeSitter/
│   │   │   │   ├── index.ts
│   │   │   │   └── treeSitterLayer.ts
│   │   │   └── types.ts
│   │   ├── shared/
│   │   │   ├── __tests__/
│   │   │   │   └── contextRootResolver.test.ts
│   │   │   ├── contentTypeRegistry.ts
│   │   │   ├── contextLayout.ts
│   │   │   ├── contextRootResolver.ts
│   │   │   ├── executionContext.ts
│   │   │   ├── globPatterns.ts
│   │   │   ├── index.ts
│   │   │   ├── pathHelpers.ts
│   │   │   ├── toolRegistry.ts
│   │   │   ├── types.ts
│   │   │   └── uiHelpers.ts
│   │   ├── stack/
│   │   │   ├── index.ts
│   │   │   ├── projectTypeClassifier.ts
│   │   │   ├── scaffoldFilter.ts
│   │   │   └── stackDetector.ts
│   │   ├── state/
│   │   │   ├── index.ts
│   │   │   ├── stateDetector.test.ts
│   │   │   └── stateDetector.ts
│   │   ├── sync/
│   │   │   ├── index.ts
│   │   │   ├── markdownReferenceHandler.ts
│   │   │   ├── presets.ts
│   │   │   ├── symlinkHandler.ts
│   │   │   ├── syncService.ts
│   │   │   └── types.ts
│   │   └── workflow/
│   │       ├── autoAdvance.ts
│   │       ├── index.ts
│   │       ├── workflowService.test.ts
│   │       └── workflowService.ts
│   ├── tests/
│   │   └── integrity/
│   │       └── postRefactoringIntegrity.test.ts
│   ├── types/
│   │   └── scaffoldFrontmatter.ts
│   ├── types.ts
│   ├── utils/
│   │   ├── cliUI.ts
│   │   ├── fileMapper.ts
│   │   ├── frontMatter.test.ts
│   │   ├── frontMatter.ts
│   │   ├── gitService.ts
│   │   ├── gitignoreManager.test.ts
│   │   ├── gitignoreManager.ts
│   │   ├── i18n.test.ts
│   │   ├── i18n.ts
│   │   ├── pathSecurity.test.ts
│   │   ├── pathSecurity.ts
│   │   ├── processShutdown.ts
│   │   ├── prompts/
│   │   │   ├── configSummary.ts
│   │   │   ├── index.ts
│   │   │   ├── smartDefaults.ts
│   │   │   └── types.ts
│   │   ├── splashScreen.test.ts
│   │   ├── splashScreen.ts
│   │   ├── theme.ts
│   │   ├── themedPrompt.ts
│   │   ├── versionChecker.test.ts
│   │   └── versionChecker.ts
│   ├── version.ts
│   └── workflow/
│       ├── agents/
│       │   ├── agentRegistry.ts
│       │   └── index.ts
│       ├── collaboration.ts
│       ├── errors.ts
│       ├── gates/
│       │   ├── gateChecker.test.ts
│       │   ├── gateChecker.ts
│       │   └── index.ts
│       ├── index.ts
│       ├── orchestration/
│       │   ├── agentOrchestrator.ts
│       │   ├── documentLinker.ts
│       │   └── index.ts
│       ├── orchestrator.ts
│       ├── phases.ts
│       ├── plans/
│       │   ├── index.ts
│       │   ├── planLinker.ts
│       │   └── types.ts
│       ├── prevcConfig.ts
│       ├── roles.ts
│       ├── scaling.ts
│       ├── skills/
│       │   ├── frontmatter.ts
│       │   ├── index.ts
│       │   ├── skillRegistry.ts
│       │   ├── skillTemplates.ts
│       │   └── types.ts
│       ├── status/
│       │   ├── statusManager.test.ts
│       │   ├── statusManager.ts
│       │   └── templates.ts
│       └── types.ts
├── templates/
│   └── packages/
│       ├── cli.README.md
│       ├── harness.README.md
│       └── mcp.README.md
└── tsconfig.json

SYMBOL INDEX (1901 symbols across 162 files)

FILE: example-documentation.ts
  function scaffoldRepo (line 11) | async function scaffoldRepo(repoRoot: string, outputDir: string = path.j...

FILE: scripts/build-package-bundles.js
  function ensureDir (line 10) | function ensureDir(dir) {
  function readJson (line 14) | function readJson(filePath) {
  function writeJson (line 18) | function writeJson(filePath, value) {
  function copyFile (line 22) | function copyFile(src, dest) {
  function copyDir (line 27) | function copyDir(src, dest) {
  function resetDir (line 41) | function resetDir(dir) {
  function writeExecutable (line 46) | function writeExecutable(filePath, content) {
  function createLocalBinShims (line 52) | function createLocalBinShims(pkgRoot, manifest) {
  function loadTemplate (line 73) | function loadTemplate(name) {
  function createManifest (line 77) | function createManifest(rootPkg, packageName, description, main, types, ...
  function packageDependencies (line 100) | function packageDependencies(rootPkg, names) {
  function buildBundles (line 110) | function buildBundles() {

FILE: scripts/release-packages.js
  function run (line 15) | function run(command, args) {
  function assert (line 22) | function assert(condition, message) {
  function resolveVersion (line 28) | function resolveVersion(input) {
  function copyDir (line 42) | function copyDir(src, dest) {
  function rewriteBundleVersion (line 55) | function rewriteBundleVersion(bundleDir, version) {
  function buildRelease (line 62) | function buildRelease(version) {
  function main (line 96) | function main() {

FILE: scripts/smoke-package-bundles.js
  function assert (line 54) | function assert(condition, message) {
  function requireFresh (line 60) | function requireFresh(filePath) {
  function runBundleCommand (line 66) | function runBundleCommand(bundleRoot, args) {
  function smokeBundle (line 74) | function smokeBundle(bundle) {
  function main (line 131) | function main() {

FILE: scripts/test-mcp.js
  function send (line 22) | function send(method, params = {}) {
  function runTests (line 43) | async function runTests() {
  function sleep (line 88) | function sleep(ms) {

FILE: src/generators/agents/agentConfig.ts
  constant AGENT_RESPONSIBILITIES (line 3) | const AGENT_RESPONSIBILITIES: Record<AgentType, string[]> = {
  constant AGENT_BEST_PRACTICES (line 96) | const AGENT_BEST_PRACTICES: Record<AgentType, string[]> = {

FILE: src/generators/agents/agentGenerator.test.ts
  function createRepoStructure (line 9) | function createRepoStructure(rootPath: string): RepoStructure {

FILE: src/generators/agents/agentGenerator.ts
  type AgentContext (line 19) | interface AgentContext {
  type AvailableSkill (line 25) | interface AvailableSkill {
  type AgentGenerationConfig (line 32) | interface AgentGenerationConfig {
  constant AGENT_SKILL_MAP (line 48) | const AGENT_SKILL_MAP: Partial<Record<AgentType, string[]>> = {
  constant AGENT_PHASES (line 61) | const AGENT_PHASES: Record<AgentType, PrevcPhase[]> = {
  function formatAgentTitle (line 81) | function formatAgentTitle(agentType: AgentType): string {
  class AgentGenerator (line 88) | class AgentGenerator {
    method constructor (line 102) | constructor(..._legacyArgs: unknown[]) {}
    method generateAgentPrompts (line 104) | async generateAgentPrompts(
    method renderSkillsSection (line 212) | private renderSkillsSection(agentType: AgentType, availableSkills: Ava...
    method getRelevantSymbolsForAgent (line 230) | private getRelevantSymbolsForAgent(agentType: AgentType, semantics?: S...
    method resolveAgentSelection (line 321) | private resolveAgentSelection(
    method buildContext (line 341) | private buildContext(repoStructure: RepoStructure, semantics?: Semanti...

FILE: src/generators/agents/agentTypes.ts
  constant AGENT_TYPES (line 1) | const AGENT_TYPES = [
  type AgentType (line 18) | type AgentType = typeof AGENT_TYPES[number];
  constant IMPORTANT_FILES (line 20) | const IMPORTANT_FILES = [

FILE: src/generators/agents/templates/indexTemplate.ts
  function renderAgentIndex (line 4) | function renderAgentIndex(agentTypes: readonly AgentType[]): string {
  function formatTitle (line 31) | function formatTitle(agentType: string): string {

FILE: src/generators/agents/templates/types.ts
  type DocTouchpoint (line 4) | interface DocTouchpoint {
  type KeySymbolInfo (line 9) | interface KeySymbolInfo {
  type AgentTemplateContext (line 16) | interface AgentTemplateContext {

FILE: src/generators/documentation/codebaseMapGenerator.ts
  type KeyFile (line 20) | interface KeyFile {
  type NavigationHints (line 26) | interface NavigationHints {
  type SemanticSnapshotMetadata (line 33) | interface SemanticSnapshotMetadata {
  type CodebaseMap (line 43) | interface CodebaseMap {
  type CodebaseMapOptions (line 109) | interface CodebaseMapOptions {
  function createEmptyFunctionalPatterns (line 114) | function createEmptyFunctionalPatterns(): DetectedFunctionalPatterns {
  constant DIRECTORY_DESCRIPTIONS (line 134) | const DIRECTORY_DESCRIPTIONS: Record<string, string> = {
  constant KEY_FILE_PATTERNS (line 189) | const KEY_FILE_PATTERNS: Array<{ pattern: RegExp; description: string; c...
  class CodebaseMapGenerator (line 208) | class CodebaseMapGenerator {
    method constructor (line 212) | constructor(options: CodebaseMapOptions = {}) {
    method generate (line 217) | generate(
    method buildStackSection (line 241) | private buildStackSection(stackInfo?: StackInfo, repoRoot?: string): C...
    method buildStructureSection (line 312) | private buildStructureSection(repoStructure: RepoStructure): CodebaseM...
    method getDirectoryDescription (line 350) | private getDirectoryDescription(dirName: string): string {
    method buildArchitectureSection (line 372) | private buildArchitectureSection(
    method categorizeEntryPoints (line 415) | private categorizeEntryPoints(entryPoints: string[]): {
    method buildDependenciesSection (line 458) | private buildDependenciesSection(repoRoot: string, semantics?: Semanti...
    method inferFileDescription (line 481) | private inferFileDescription(filePath: string): string | undefined {
    method buildStatsSection (line 521) | private buildStatsSection(repoStructure: RepoStructure, semantics?: Se...
    method relativePath (line 549) | private relativePath(repoRoot: string, filePath: string): string {
    method buildKeyFilesSection (line 556) | private buildKeyFilesSection(repoStructure: RepoStructure, semantics?:...
    method enhanceFileDescription (line 608) | private enhanceFileDescription(
    method inferCategory (line 638) | private inferCategory(filePath: string): KeyFile['category'] {
    method buildNavigationSection (line 655) | private buildNavigationSection(repoStructure: RepoStructure, stackInfo...

FILE: src/generators/documentation/documentationGenerator.test.ts
  function createRepoStructure (line 9) | function createRepoStructure(rootPath: string): RepoStructure {

FILE: src/generators/documentation/documentationGenerator.ts
  constant DOC_CATEGORY_MAP (line 25) | const DOC_CATEGORY_MAP: Record<string, DocScaffoldFrontmatter['category'...
  function getDocInfo (line 39) | function getDocInfo(key: string): { title: string; description: string; ...
  type DocumentationGenerationConfig (line 51) | interface DocumentationGenerationConfig {
  class DocumentationGenerator (line 62) | class DocumentationGenerator {
    method constructor (line 65) | constructor(..._legacyArgs: unknown[]) {}
    method generateDocumentation (line 67) | async generateDocumentation(
    method buildContext (line 183) | private buildContext(
    method deriveTopLevelDirectories (line 213) | private deriveTopLevelDirectories(repoStructure: RepoStructure): strin...
    method updateAgentGuideReferences (line 224) | private async updateAgentGuideReferences(repoStructure: RepoStructure,...
    method createDefaultAgentGuide (line 256) | private createDefaultAgentGuide(repoStructure: RepoStructure): string {

FILE: src/generators/documentation/guideRegistry.ts
  constant DOCUMENT_GUIDES (line 3) | const DOCUMENT_GUIDES: GuideMeta[] = [
  constant DOCUMENT_GUIDE_KEYS (line 54) | const DOCUMENT_GUIDE_KEYS = DOCUMENT_GUIDES.map(guide => guide.key);
  function getGuidesByKeys (line 56) | function getGuidesByKeys(keys?: string[]): GuideMeta[] {
  function getDocFilesByKeys (line 66) | function getDocFilesByKeys(keys?: string[]): Set<string> | undefined {

FILE: src/generators/documentation/templates/common.ts
  function wrapWithFrontMatter (line 9) | function wrapWithFrontMatter(
  constant KNOWN_DESCRIPTIONS (line 24) | const KNOWN_DESCRIPTIONS: Record<string, string> = {
  function formatDirectoryList (line 33) | function formatDirectoryList(
  function buildDocumentMapTable (line 57) | function buildDocumentMapTable(guides: DocumentationTemplateContext['gui...
  function formatDirectoryStats (line 62) | function formatDirectoryStats(stats: DirectoryStat[]): string {
  function formatInlineDirectoryList (line 72) | function formatInlineDirectoryList(directories: string[]): string {
  function formatSymbolRef (line 86) | function formatSymbolRef(
  function formatCodeLocation (line 98) | function formatCodeLocation(
  function formatFileRef (line 111) | function formatFileRef(
  function buildSymbolTable (line 125) | function buildSymbolTable(
  function buildSymbolList (line 168) | function buildSymbolList(
  function groupSymbolsByDirectory (line 188) | function groupSymbolsByDirectory(

FILE: src/generators/documentation/templates/indexTemplate.ts
  function renderIndex (line 4) | function renderIndex(context: DocumentationTemplateContext): string {

FILE: src/generators/documentation/templates/types.ts
  type GuideMeta (line 4) | interface GuideMeta {
  type DirectoryStat (line 11) | interface DirectoryStat {
  type DocumentationTemplateContext (line 16) | interface DocumentationTemplateContext {

FILE: src/generators/plans/planGenerator.test.ts
  function createTempOutput (line 7) | function createTempOutput(prefix: string): Promise<string> {

FILE: src/generators/plans/planGenerator.ts
  type PlanGeneratorOptions (line 13) | interface PlanGeneratorOptions {
  type PlanGenerationResult (line 26) | interface PlanGenerationResult {
  class PlanGenerator (line 32) | class PlanGenerator {
    method generatePlan (line 35) | async generatePlan(options: PlanGeneratorOptions): Promise<PlanGenerat...
    method resolveAgents (line 118) | private resolveAgents(selected?: string[] | null): PlanAgentSummary[] {
    method buildCodebaseSnapshot (line 137) | private buildCodebaseSnapshot(semantics: SemanticContext): CodebaseSna...
    method updatePlanIndex (line 149) | private async updatePlanIndex(plansDir: string, verbose: boolean): Pro...

FILE: src/generators/plans/templates/indexTemplate.ts
  function renderPlanIndex (line 3) | function renderPlanIndex(entries: PlanIndexEntry[]): string {

FILE: src/generators/plans/templates/planTemplate.ts
  function wrapWithPlanFrontMatter (line 19) | function wrapWithPlanFrontMatter(
  function renderCodebaseSnapshot (line 58) | function renderCodebaseSnapshot(snapshot?: CodebaseSnapshot): string {
  function renderKeyComponents (line 83) | function renderKeyComponents(semantics?: SemanticContext): string {
  function renderPlanTemplate (line 115) | function renderPlanTemplate(context: PlanTemplateContext): string {

FILE: src/generators/plans/templates/types.ts
  type PlanAgentSummary (line 5) | interface PlanAgentSummary {
  type CodebaseSnapshot (line 11) | interface CodebaseSnapshot {
  type PlanTemplateContext (line 19) | interface PlanTemplateContext {
  type PlanIndexEntry (line 29) | interface PlanIndexEntry {

FILE: src/generators/shared/contextGenerator.ts
  class ContextGenerator (line 3) | class ContextGenerator {
    method constructor (line 4) | constructor(protected readonly fileMapper: FileMapper) {}
    method loadFileContent (line 6) | protected async loadFileContent(path: string): Promise<string> {

FILE: src/generators/shared/directoryTemplateHelpers.ts
  function formatDirectoryList (line 1) | function formatDirectoryList(directories: string[], placeholderMessage?:...

FILE: src/generators/shared/generatorUtils.ts
  class GeneratorUtils (line 6) | class GeneratorUtils {
    method formatBytes (line 7) | static formatBytes(bytes: number): string {
    method slugify (line 15) | static slugify(text: string): string {
    method formatModuleName (line 22) | static formatModuleName(name: string): string {
    method formatTitle (line 29) | static formatTitle(text: string): string {
    method ensureDirectoryAndLog (line 35) | static async ensureDirectoryAndLog(dir: string, verbose: boolean, desc...
    method writeFileWithLogging (line 42) | static async writeFileWithLogging(
    method logError (line 61) | static logError(message: string, error: any, verbose: boolean): void {
    method logProgress (line 67) | static logProgress(message: string, verbose: boolean): void {
    method getFileTypeDistribution (line 73) | static getFileTypeDistribution(repoStructure: RepoStructure): Map<stri...
    method getTopFileExtensions (line 82) | static getTopFileExtensions(repoStructure: RepoStructure, limit: numbe...
    method createTimestamp (line 89) | static createTimestamp(): string {
    method createGeneratedByFooter (line 93) | static createGeneratedByFooter(additionalInfo?: string): string {

FILE: src/generators/shared/structures/agents/factory.ts
  type AgentDefaultContent (line 10) | interface AgentDefaultContent {
  constant SECTION_KEY_MAP (line 27) | const SECTION_KEY_MAP: Record<string, keyof AgentDefaultContent> = {
  function createAgentStructure (line 44) | function createAgentStructure(

FILE: src/generators/shared/structures/documentation/architecture.ts
  constant SEMANTIC_SNAPSHOT_GUIDANCE (line 3) | const SEMANTIC_SNAPSHOT_GUIDANCE =

FILE: src/generators/shared/structures/documentation/projectOverview.ts
  constant SEMANTIC_SNAPSHOT_GUIDANCE (line 3) | const SEMANTIC_SNAPSHOT_GUIDANCE =

FILE: src/generators/shared/structures/registry.ts
  constant SCAFFOLD_STRUCTURES (line 15) | const SCAFFOLD_STRUCTURES: Record<string, ScaffoldStructure> = {
  function getScaffoldStructure (line 65) | function getScaffoldStructure(name: string): ScaffoldStructure | undefin...
  function getStructuresByType (line 72) | function getStructuresByType(fileType: ScaffoldFileType): ScaffoldStruct...

FILE: src/generators/shared/structures/serialization.ts
  function serializeStructureAsMarkdown (line 12) | function serializeStructureAsMarkdown(structure: ScaffoldStructure): str...
  function formatSectionAsMarkdown (line 40) | function formatSectionAsMarkdown(section: ScaffoldSection): string {
  function getPlaceholderForContentType (line 72) | function getPlaceholderForContentType(contentType: string, required: boo...
  function serializeStructureForAI (line 96) | function serializeStructureForAI(structure: ScaffoldStructure): string {

FILE: src/generators/shared/structures/skills/factory.ts
  type SkillDefaultContent (line 10) | interface SkillDefaultContent {
  constant SECTION_KEY_MAP (line 20) | const SECTION_KEY_MAP: Record<string, keyof SkillDefaultContent> = {
  constant RESOURCE_STRATEGY_DEFAULT (line 26) | const RESOURCE_STRATEGY_DEFAULT = `- Add \`scripts/\` only when the task...
  function createSkillStructure (line 34) | function createSkillStructure(

FILE: src/generators/shared/structures/types.ts
  type ScaffoldContentType (line 10) | type ScaffoldContentType =
  type ScaffoldTone (line 21) | type ScaffoldTone =
  type ScaffoldAudience (line 30) | type ScaffoldAudience =
  type ScaffoldSection (line 39) | interface ScaffoldSection {
  type ScaffoldStructure (line 61) | interface ScaffoldStructure {

FILE: src/generators/shared/structures/validation.ts
  function validateStructure (line 11) | function validateStructure(structure: ScaffoldStructure): string[] {
  function validateAllStructures (line 46) | function validateAllStructures(): Map<string, string[]> {

FILE: src/generators/skills/skillGenerator.ts
  type SkillGeneratorOptions (line 30) | interface SkillGeneratorOptions {
  type SkillGeneratorResult (line 41) | interface SkillGeneratorResult {
  class SkillGenerator (line 48) | class SkillGenerator {
    method constructor (line 53) | constructor(options: SkillGeneratorOptions) {
    method generate (line 62) | async generate(options: {
    method formatSkillTitle (line 132) | private formatSkillTitle(skillName: string): string {
    method buildSkillBody (line 139) | private buildSkillBody(skillName: string): string {
    method generateCustomSkill (line 184) | async generateCustomSkill(options: {
    method generateIndex (line 223) | async generateIndex(): Promise<string> {
  function createSkillGenerator (line 243) | function createSkillGenerator(options: SkillGeneratorOptions): SkillGene...

FILE: src/generators/skills/templates/indexTemplate.ts
  type SkillsIndexOptions (line 7) | interface SkillsIndexOptions {
  function generateSkillsIndex (line 15) | function generateSkillsIndex(options: SkillsIndexOptions): string {

FILE: src/generators/skills/templates/skillTemplate.ts
  type SkillTemplateOptions (line 18) | interface SkillTemplateOptions {
  function generateSkillContent (line 29) | function generateSkillContent(options: SkillTemplateOptions): string {
  function buildFrontmatter (line 45) | function buildFrontmatter(options: SkillTemplateOptions): string {
  function buildBody (line 68) | function buildBody(name: string, description: string): string {
  function getDefaultPhases (line 109) | function getDefaultPhases(skillName: string): PrevcPhase[] {

FILE: src/index.ts
  function scheduleVersionCheck (line 106) | function scheduleVersionCheck(force: boolean = false): Promise<void> {
  function registerSyncCommand (line 124) | function registerSyncCommand(parent: Command, name: string, hidden = fal...
  function registerPreviewSplashCommand (line 300) | function registerPreviewSplashCommand(parent: Command, hidden = false): ...
  function registerExportRulesCommand (line 317) | function registerExportRulesCommand(parent: Command, hidden = false): Co...
  function registerReportCommand (line 352) | function registerReportCommand(parent: Command, hidden = false): Command {
  function registerSkillCommands (line 385) | function registerSkillCommands(parent: Command, hidden = false): Command {
  function registerWorkflowCommands (line 479) | function registerWorkflowCommands(parent: Command, hidden = false): Comm...
  function selectLocale (line 654) | async function selectLocale(): Promise<void> {
  type InteractiveAction (line 669) | type InteractiveAction = 'syncAgents' | 'update' | 'changeLanguage' | 'e...
  type StateAction (line 670) | type StateAction = 'exit' | 'mcpInstall' | 'reverseSync' | 'settings';
  function runInteractive (line 672) | async function runInteractive(): Promise<void> {
  function runFullMenu (line 763) | async function runFullMenu(): Promise<void> {
  function displayPendingFiles (line 819) | async function displayPendingFiles(contextDir: string): Promise<void> {
  function runMcpInstall (line 832) | async function runMcpInstall(): Promise<void> {
  function runInteractiveSync (line 854) | async function runInteractiveSync(): Promise<void> {
  function runQuickSync (line 936) | async function runQuickSync(): Promise<void> {
  function runReverseSync (line 1081) | async function runReverseSync(): Promise<void> {
  function runSettings (line 1185) | async function runSettings(): Promise<void> {
  function renderStartupSplash (line 1190) | async function renderStartupSplash(
  function filterOutLocaleArgs (line 1208) | function filterOutLocaleArgs(args: string[]): string[] {
  function main (line 1224) | async function main(): Promise<void> {
  function isUserInterrupt (line 1239) | function isUserInterrupt(error: unknown): boolean {
  function handleGracefulExit (line 1253) | function handleGracefulExit(): void {

FILE: src/mcp/bin.ts
  type ParsedArgs (line 17) | type ParsedArgs = {
  function parseMcpPackageArgs (line 61) | function parseMcpPackageArgs(argv: string[]): ParsedArgs {
  function parseServeArgs (line 84) | function parseServeArgs(args: string[]): ParsedArgs {
  function parseInstallArgs (line 105) | function parseInstallArgs(args: string[]): ParsedArgs {
  function printHelp (line 152) | function printHelp(): void {
  function runInstallCommand (line 167) | async function runInstallCommand(args: ParsedArgs, argv: string[]): Prom...
  function runServeCommand (line 209) | async function runServeCommand(args: ParsedArgs): Promise<void> {
  function runMcpPackage (line 225) | async function runMcpPackage(argv: string[]): Promise<void> {

FILE: src/prompts/defaults.ts
  constant UPDATE_SCAFFOLD_PROMPT_FALLBACK (line 1) | const UPDATE_SCAFFOLD_PROMPT_FALLBACK = `# Prompt: Update Repository Doc...
  constant MCP_SCAFFOLD_ENHANCEMENT_PROMPT (line 34) | const MCP_SCAFFOLD_ENHANCEMENT_PROMPT = `# AI Enhancement Required
  constant UPDATE_PLAN_PROMPT_FALLBACK (line 74) | const UPDATE_PLAN_PROMPT_FALLBACK = `# Prompt: Update Collaboration Plans

FILE: src/services/autoFill/autoFillService.ts
  type AutoFillContext (line 14) | interface AutoFillContext {
  type DirectoryStat (line 21) | interface DirectoryStat {
  constant SEMANTIC_SNAPSHOT_REFERENCE (line 26) | const SEMANTIC_SNAPSHOT_REFERENCE =
  class AutoFillService (line 29) | class AutoFillService {
    method fillDocumentation (line 33) | fillDocumentation(
    method fillAgent (line 60) | fillAgent(
    method fillSection (line 75) | private fillSection(
    method fillAgentSection (line 85) | private fillAgentSection(
    method generateDocContent (line 95) | private generateDocContent(
    method generateAgentContent (line 117) | private generateAgentContent(
    method fillProjectOverviewSection (line 147) | private fillProjectOverviewSection(section: ScaffoldSection, ctx: Auto...
    method fillArchitectureSection (line 185) | private fillArchitectureSection(section: ScaffoldSection, ctx: AutoFil...
    method fillToolingSection (line 211) | private fillToolingSection(section: ScaffoldSection, ctx: AutoFillCont...
    method generateProjectOverview (line 231) | private generateProjectOverview(ctx: AutoFillContext): string {
    method generateQuickFacts (line 249) | private generateQuickFacts(ctx: AutoFillContext): string {
    method formatEntryPoints (line 275) | private formatEntryPoints(entryPoints: string[]): string {
    method formatPublicAPI (line 283) | private formatPublicAPI(symbols: ExtractedSymbol[]): string {
    method formatPublicAPITable (line 297) | private formatPublicAPITable(symbols: ExtractedSymbol[]): string {
    method formatDirectoryStructure (line 315) | private formatDirectoryStructure(directories: string[]): string {
    method formatTechStack (line 326) | private formatTechStack(stackInfo?: StackInfo): string {
    method formatFrameworks (line 356) | private formatFrameworks(stackInfo?: StackInfo): string {
    method formatBuildTools (line 364) | private formatBuildTools(stackInfo?: StackInfo): string {
    method formatTestFrameworks (line 372) | private formatTestFrameworks(stackInfo?: StackInfo): string {
    method formatPackageManager (line 380) | private formatPackageManager(stackInfo?: StackInfo): string {
    method formatLayers (line 388) | private formatLayers(layers: ArchitectureLayer[]): string {
    method formatPatterns (line 403) | private formatPatterns(patterns: DetectedPattern[]): string {
    method generateGettingStarted (line 422) | private generateGettingStarted(stackInfo?: StackInfo): string {
    method generateKeyFilesForAgent (line 467) | private generateKeyFilesForAgent(agentType: string, ctx: AutoFillConte...
    method generateRelevantSymbolsForAgent (line 496) | private generateRelevantSymbolsForAgent(agentType: string, ctx: AutoFi...
    method getFilePatternForAgent (line 515) | private getFilePatternForAgent(agentType: string): RegExp[] {
    method getRelevantSymbolsForAgent (line 547) | private getRelevantSymbolsForAgent(agentType: string, semantics: Seman...

FILE: src/services/cli/mcpInstallService.ts
  type MCPInstallServiceDependencies (line 25) | type MCPInstallServiceDependencies = BaseDependencies;
  type MCPInstallOptions (line 27) | interface MCPInstallOptions {
  type MCPInstallResult (line 40) | interface MCPInstallResult extends OperationResult {
  type MCPInstallation (line 44) | interface MCPInstallation {
  type MCPInstallToolChoice (line 52) | interface MCPInstallToolChoice {
  type MCPInstallToolPrompt (line 57) | interface MCPInstallToolPrompt {
  type ResolveMcpInstallToolSelectionOptions (line 62) | interface ResolveMcpInstallToolSelectionOptions {
  type MCPServerConfig (line 74) | interface MCPServerConfig {
  type MCPConfigTemplate (line 80) | interface MCPConfigTemplate {
  constant AI_CONTEXT_MCP_SERVER (line 98) | const AI_CONTEXT_MCP_SERVER: MCPServerConfig = {
  function buildCodexTomlConfig (line 107) | function buildCodexTomlConfig(existingConfig: string, server: MCPServerC...
  constant MCP_CONFIG_TEMPLATES (line 129) | const MCP_CONFIG_TEMPLATES: MCPConfigTemplate[] = [
  class MCPInstallService (line 499) | class MCPInstallService {
    method constructor (line 500) | constructor(private deps: MCPInstallServiceDependencies) {}
    method getSupportedTools (line 505) | getSupportedTools(): ToolDefinition[] {
    method getSupportedToolIds (line 512) | getSupportedToolIds(): string[] {
    method detectInstalledTools (line 519) | async detectInstalledTools(): Promise<string[]> {
    method run (line 540) | async run(options: MCPInstallOptions = {}): Promise<MCPInstallResult> {
    method installForTool (line 607) | private async installForTool(
  function buildMcpInstallToolChoices (line 719) | function buildMcpInstallToolChoices(
  function resolveMcpInstallToolSelection (line 744) | async function resolveMcpInstallToolSelection(

FILE: src/services/cli/stateDetector.ts
  type ProjectState (line 18) | type ProjectState = 'new' | 'unfilled' | 'ready' | 'outdated';
  type StateDetectionResult (line 20) | interface StateDetectionResult {
  type StateDetectorOptions (line 34) | interface StateDetectorOptions {
  constant DEFAULT_SOURCE_DIRS (line 40) | const DEFAULT_SOURCE_DIRS = ['src', 'lib', 'app', 'packages'];
  class StateDetector (line 42) | class StateDetector {
    method constructor (line 47) | constructor(options: StateDetectorOptions) {
    method contextDir (line 53) | get contextDir(): string {
    method detect (line 60) | async detect(): Promise<StateDetectionResult> {
    method getNewestMtime (line 133) | private async getNewestMtime(dirs: string[]): Promise<Date | undefined> {
    method getContextMtime (line 165) | private async getContextMtime(): Promise<Date | undefined> {
    method describeState (line 187) | static describeState(result: StateDetectionResult): string {

FILE: src/services/export/contextExportService.ts
  type ContextExportServiceDependencies (line 19) | type ContextExportServiceDependencies = BaseDependencies;
  type ContextExportOptions (line 21) | interface ContextExportOptions {
  type ContextExportResult (line 44) | interface ContextExportResult extends OperationResult {
  class ContextExportService (line 51) | class ContextExportService {
    method constructor (line 52) | constructor(private deps: ContextExportServiceDependencies) {}
    method run (line 57) | async run(repoPath: string, options: ContextExportOptions = {}): Promi...

FILE: src/services/export/exportRulesService.ts
  type ExportRulesServiceDependencies (line 24) | type ExportRulesServiceDependencies = BaseDependencies;
  type ExportTarget (line 26) | interface ExportTarget {
  type ExportOptions (line 35) | interface ExportOptions {
  type ExportResult (line 46) | interface ExportResult extends OperationResult {
  type RuleFile (line 50) | interface RuleFile {
  function buildExportPresets (line 59) | function buildExportPresets(): Record<string, ExportTarget[]> {
  function deduplicateTargets (line 91) | function deduplicateTargets(targets: ExportTarget[]): ExportTarget[] {
  constant EXPORT_PRESETS (line 108) | const EXPORT_PRESETS: Record<string, ExportTarget[]> = buildExportPreset...
  class ExportRulesService (line 110) | class ExportRulesService {
    method constructor (line 111) | constructor(private deps: ExportRulesServiceDependencies) {}
    method run (line 116) | async run(repoPath: string, options: ExportOptions = {}): Promise<Expo...
    method exportToTarget (line 167) | private async exportToTarget(
    method resolveTargets (line 236) | private resolveTargets(options: ExportOptions): ExportTarget[] {
    method readSourceRules (line 277) | private async readSourceRules(sourcePath: string, indexMode?: 'readme'...
    method readReadmeIndexFiles (line 323) | private async readReadmeIndexFiles(sourcePath: string): Promise<RuleFi...
    method combineRules (line 356) | private combineRules(rules: RuleFile[]): string {
    method exportToDirectory (line 374) | private async exportToDirectory(
    method getAvailablePresets (line 390) | getAvailablePresets(): string[] {

FILE: src/services/export/skillExportService.ts
  type SkillExportServiceDependencies (line 21) | type SkillExportServiceDependencies = BaseDependencies;
  type SkillExportTarget (line 23) | interface SkillExportTarget {
  type SkillExportOptions (line 29) | interface SkillExportOptions {
  type SkillExportResult (line 41) | interface SkillExportResult extends OperationResult {
  function buildSkillExportPresets (line 49) | function buildSkillExportPresets(): Record<string, SkillExportTarget[]> {
  constant SKILL_EXPORT_PRESETS (line 68) | const SKILL_EXPORT_PRESETS: Record<string, SkillExportTarget[]> = buildS...
  class SkillExportService (line 70) | class SkillExportService {
    method constructor (line 71) | constructor(private deps: SkillExportServiceDependencies) {}
    method run (line 76) | async run(repoPath: string, options: SkillExportOptions = {}): Promise...
    method getSkillsToExport (line 124) | private async getSkillsToExport(repoPath: string, options: SkillExport...
    method exportToTarget (line 174) | private async exportToTarget(
    method exportSkill (line 214) | private async exportSkill(
    method generateSkillContent (line 258) | private generateSkillContent(skill: Skill): string {
    method resolveTargets (line 273) | private resolveTargets(options: SkillExportOptions): SkillExportTarget...
    method getAvailablePresets (line 307) | getAvailablePresets(): string[] {

FILE: src/services/harness/agentsService.ts
  type HarnessAgentsServiceOptions (line 18) | interface HarnessAgentsServiceOptions {
  class HarnessAgentsService (line 22) | class HarnessAgentsService {
    method constructor (line 23) | constructor(private readonly options: HarnessAgentsServiceOptions) {}
    method repoPath (line 25) | private get repoPath(): string {
    method discover (line 29) | async discover(): Promise<Record<string, unknown>> {
    method getInfo (line 48) | async getInfo(agentType: string): Promise<Record<string, unknown>> {
    method orchestrate (line 58) | orchestrate(params: {
    method getSequence (line 90) | getSequence(params: {
    method getDocs (line 118) | getDocs(agent: AgentType): Record<string, unknown> {
    method getPhaseDocs (line 137) | getPhaseDocs(phase: PrevcPhase): Record<string, unknown> {
    method listTypes (line 157) | listTypes(): Record<string, unknown> {

FILE: src/services/harness/contextService.ts
  type HarnessContextServiceOptions (line 28) | interface HarnessContextServiceOptions {
  type HarnessContextInitResult (line 33) | interface HarnessContextInitResult {
  type HarnessContextPlanScaffoldResult (line 44) | interface HarnessContextPlanScaffoldResult {
  type HarnessBootstrapStatusResult (line 55) | interface HarnessBootstrapStatusResult {
  class HarnessContextService (line 94) | class HarnessContextService {
    method constructor (line 95) | constructor(private readonly options: HarnessContextServiceOptions) {}
    method repoPath (line 97) | private get repoPath(): string {
    method check (line 101) | async check(repoPath?: string): Promise<unknown> {
    method bootstrapStatus (line 108) | async bootstrapStatus(repoPath?: string): Promise<HarnessBootstrapStat...
    method init (line 202) | async init(params: {
    method fill (line 277) | async fill(params: {
    method fillSingle (line 296) | async fillSingle(params: { repoPath?: string; filePath: string }): Pro...
    method listToFill (line 303) | async listToFill(params: {
    method getMap (line 318) | async getMap(params: { repoPath?: string; section?: string }): Promise...
    method buildSemantic (line 328) | async buildSemantic(params: {
    method scaffoldPlan (line 366) | async scaffoldPlan(params: {
    method searchQA (line 417) | async searchQA(params: {
    method generateQA (line 440) | async generateQA(params: {
    method getFlow (line 464) | async getFlow(params: {
    method detectPatterns (line 495) | async detectPatterns(params: {
  function buildPlanWorkflowPrompt (line 531) | function buildPlanWorkflowPrompt(params: {
  function buildPlanWorkflowNextSteps (line 559) | function buildPlanWorkflowNextSteps(params: {

FILE: src/services/harness/contextTools.ts
  type ToolContext (line 31) | type ToolContext = unknown;
  type InternalTool (line 33) | interface InternalTool<TInput, TOutput> {
  function createInternalTool (line 38) | function createInternalTool<TInput, TOutput>(
  type ScaffoldTarget (line 45) | type ScaffoldTarget = 'docs' | 'agents' | 'skills' | 'plans' | 'sensors'...
  type ScaffoldFileType (line 46) | type ScaffoldFileType = 'doc' | 'agent' | 'skill' | 'plan' | 'sensor';
  type ScaffoldFileInfo (line 48) | interface ScaffoldFileInfo {
  type RequiredAction (line 55) | interface RequiredAction {
  function collectScaffoldFiles (line 64) | async function collectScaffoldFiles(
  function resolveScaffoldFileInfo (line 155) | function resolveScaffoldFileInfo(outputDir: string, filePath: string): S...
  function getDocFillInstructions (line 205) | function getDocFillInstructions(fileName: string): string {
  function getAgentFillInstructions (line 209) | function getAgentFillInstructions(agentType: string): string {
  function getSkillFillInstructions (line 213) | function getSkillFillInstructions(skillSlug: string): string {
  function getSensorFillInstructions (line 217) | function getSensorFillInstructions(): string {
  function sensorCatalogNeedsFill (line 221) | async function sensorCatalogNeedsFill(filePath: string): Promise<boolean> {
  function hasContent (line 230) | async function hasContent(dirPath: string): Promise<boolean> {
  function hasSkillContent (line 239) | async function hasSkillContent(skillsDir: string): Promise<boolean> {
  function hasHarnessRuntimeContent (line 256) | async function hasHarnessRuntimeContent(harnessDir: string): Promise<boo...
  function getTreeSitterLayer (line 268) | function getTreeSitterLayer(): TreeSitterLayer {
  function getOrBuildContext (line 278) | async function getOrBuildContext(repoPath: string): Promise<string> {
  function cleanupSharedContext (line 309) | async function cleanupSharedContext(): Promise<void> {
  constant TOOL_NAMES (line 1183) | const TOOL_NAMES = [
  type ToolName (line 1198) | type ToolName = (typeof TOOL_NAMES)[number];

FILE: src/services/harness/datasetService.ts
  type HarnessFailureKind (line 10) | type HarnessFailureKind = 'sensor' | 'task' | 'session' | 'trace';
  type HarnessFailureRecord (line 12) | interface HarnessFailureRecord {
  type HarnessFailureCluster (line 24) | interface HarnessFailureCluster {
  type HarnessFailureDataset (line 33) | interface HarnessFailureDataset {
  type HarnessDatasetServiceOptions (line 45) | interface HarnessDatasetServiceOptions {
  type BuildHarnessDatasetOptions (line 50) | interface BuildHarnessDatasetOptions {
  type HarnessDatasetDependencies (line 55) | interface HarnessDatasetDependencies {
  function nowIso (line 61) | function nowIso(): string {
  function normalizeSignature (line 65) | function normalizeSignature(value: string): string {
  function buildSensorFailures (line 73) | function buildSensorFailures(replay: HarnessReplayRecord): HarnessFailur...
  function buildTaskFailures (line 93) | async function buildTaskFailures(
  function buildSessionFailure (line 126) | function buildSessionFailure(replay: HarnessReplayRecord): HarnessFailur...
  function buildTraceFailures (line 150) | function buildTraceFailures(replay: HarnessReplayRecord): HarnessFailure...
  function clusterFailures (line 170) | function clusterFailures(failures: HarnessFailureRecord[]): HarnessFailu...
  class HarnessDatasetService (line 205) | class HarnessDatasetService {
    method constructor (line 210) | constructor(private readonly options: HarnessDatasetServiceOptions) {
    method repoPath (line 236) | private get repoPath(): string {
    method datasetsPath (line 240) | private get datasetsPath(): string {
    method datasetFile (line 244) | private datasetFile(datasetId: string): string {
    method ensureLayout (line 248) | private async ensureLayout(): Promise<void> {
    method buildFailureDataset (line 252) | async buildFailureDataset(options: BuildHarnessDatasetOptions = {}): P...
    method listDatasets (line 289) | async listDatasets(): Promise<HarnessFailureDataset[]> {
    method getDataset (line 301) | async getDataset(datasetId: string): Promise<HarnessFailureDataset> {
    method getFailureClusters (line 310) | async getFailureClusters(datasetId: string): Promise<HarnessFailureClu...

FILE: src/services/harness/executionService.ts
  type HarnessExecutionServiceOptions (line 36) | interface HarnessExecutionServiceOptions {
  type HarnessSessionQualitySnapshot (line 40) | interface HarnessSessionQualitySnapshot {
  class HarnessExecutionService (line 47) | class HarnessExecutionService {
    method constructor (line 55) | constructor(private readonly options: HarnessExecutionServiceOptions) {
    method createSession (line 81) | createSession(input: CreateSessionInput) {
    method listSessions (line 85) | listSessions() {
    method getSession (line 89) | getSession(sessionId: string) {
    method appendTrace (line 93) | appendTrace(sessionId: string, input: AppendTraceInput) {
    method listTraces (line 97) | listTraces(sessionId: string) {
    method addArtifact (line 101) | async addArtifact(sessionId: string, input: AddArtifactInput) {
    method listArtifacts (line 112) | listArtifacts(sessionId: string) {
    method checkpointSession (line 116) | async checkpointSession(sessionId: string, input: CheckpointInput = {}) {
    method resumeSession (line 126) | resumeSession(sessionId: string) {
    method completeSession (line 130) | async completeSession(sessionId: string, note?: string) {
    method failSession (line 140) | async failSession(sessionId: string, message: string) {
    method runSensor (line 150) | async runSensor(
    method getSessionSensorRuns (line 170) | getSessionSensorRuns(sessionId: string) {
    method createTaskContract (line 174) | async createTaskContract(input: Parameters<HarnessTaskContractsService...
    method listTaskContracts (line 184) | listTaskContracts() {
    method evaluateTaskCompletion (line 188) | evaluateTaskCompletion(taskId: string, sessionId?: string): Promise<Ha...
    method createHandoffContract (line 192) | async createHandoffContract(input: Parameters<HarnessTaskContractsServ...
    method listHandoffContracts (line 202) | listHandoffContracts() {
    method listPolicies (line 206) | listPolicies(): Promise<HarnessPolicyRule[]> {
    method registerPolicy (line 210) | registerPolicy(input: {
    method getPolicy (line 235) | getPolicy(): Promise<HarnessPolicyDocument> {
    method setPolicy (line 239) | setPolicy(input: {
    method resetPolicy (line 251) | async resetPolicy(): Promise<HarnessPolicyDocument> {
    method evaluatePolicy (line 255) | evaluatePolicy(input: HarnessPolicyEvaluationInput): Promise<HarnessPo...
    method replaySession (line 259) | replaySession(sessionId: string): Promise<HarnessReplayRecord> {
    method listReplays (line 263) | listReplays(sessionId?: string): Promise<HarnessReplayRecord[]> {
    method exportFailureDataset (line 267) | exportFailureDataset(sessionIds?: string[]): Promise<HarnessFailureDat...
    method listDatasets (line 274) | listDatasets(): Promise<HarnessFailureDataset[]> {
    method getDataset (line 278) | getDataset(datasetId: string): Promise<HarnessFailureDataset> {
    method getFailureClusters (line 282) | getFailureClusters(datasetId: string): Promise<HarnessFailureCluster[]> {
    method getSessionQuality (line 286) | async getSessionQuality(

FILE: src/services/harness/plansService.ts
  type HarnessPlansServiceOptions (line 17) | interface HarnessPlansServiceOptions {
  class HarnessPlansService (line 21) | class HarnessPlansService {
    method constructor (line 24) | constructor(private readonly options: HarnessPlansServiceOptions) {
    method repoPath (line 30) | private get repoPath(): string {
    method link (line 34) | async link(planSlug: string): Promise<Record<string, unknown>> {
    method getLinked (line 99) | async getLinked(): Promise<Record<string, unknown>> {
    method getDetails (line 104) | async getDetails(planSlug: string): Promise<Record<string, unknown>> {
    method getForPhase (line 126) | async getForPhase(phase: PrevcPhase): Promise<Record<string, unknown>> {
    method updatePhase (line 144) | async updatePhase(planSlug: string, phaseId: string, status: 'pending'...
    method recordDecision (line 149) | async recordDecision(params: {
    method updateStep (line 167) | async updateStep(params: {
    method getStatus (line 192) | async getStatus(planSlug: string): Promise<Record<string, unknown>> {
    method syncMarkdown (line 205) | async syncMarkdown(planSlug: string): Promise<Record<string, unknown>> {
    method commitPhase (line 215) | async commitPhase(params: {

FILE: src/services/harness/policyService.ts
  type HarnessPolicyEffect (line 5) | type HarnessPolicyEffect = 'allow' | 'deny' | 'require_approval';
  type HarnessPolicyRisk (line 6) | type HarnessPolicyRisk = 'low' | 'medium' | 'high' | 'critical';
  type HarnessPolicyTarget (line 7) | type HarnessPolicyTarget = 'tool' | 'action' | 'path' | 'risk';
  type HarnessPolicyScope (line 8) | type HarnessPolicyScope = HarnessPolicyTarget;
  type HarnessPolicyDefaultEffect (line 9) | type HarnessPolicyDefaultEffect = 'allow' | 'deny';
  type HarnessPolicyRuleSelector (line 11) | interface HarnessPolicyRuleSelector {
  type HarnessPolicyRule (line 18) | interface HarnessPolicyRule {
  type HarnessPolicyDocument (line 28) | interface HarnessPolicyDocument {
  type HarnessPolicyApproval (line 34) | interface HarnessPolicyApproval {
  type HarnessPolicyEvaluationInput (line 39) | interface HarnessPolicyEvaluationInput {
  type HarnessPolicyLegacyEnforcementInput (line 50) | interface HarnessPolicyLegacyEnforcementInput {
  type HarnessPolicyMatch (line 60) | interface HarnessPolicyMatch {
  type HarnessPolicyDecision (line 67) | interface HarnessPolicyDecision {
  type HarnessPolicyEvaluationResult (line 76) | type HarnessPolicyEvaluationResult = HarnessPolicyDecision;
  type CreateHarnessPolicyRuleInput (line 78) | interface CreateHarnessPolicyRuleInput {
  type HarnessPolicyServiceOptions (line 87) | interface HarnessPolicyServiceOptions {
  type CreateHarnessBootstrapPolicyOptions (line 91) | interface CreateHarnessBootstrapPolicyOptions {
  class HarnessPolicyBlockedError (line 95) | class HarnessPolicyBlockedError extends Error {
    method constructor (line 96) | constructor(
  function normalizePath (line 105) | function normalizePath(input: string): string {
  function escapeRegex (line 109) | function escapeRegex(input: string): string {
  function globToRegExp (line 113) | function globToRegExp(pattern: string): RegExp {
  function matchesAnyPattern (line 127) | function matchesAnyPattern(value: string, patterns: string[]): boolean {
  function riskRank (line 139) | function riskRank(risk: HarnessPolicyRisk): number {
  function compareRisk (line 148) | function compareRisk(inputRisk: HarnessPolicyRisk | undefined, ruleRisk:...
  function normalizeRule (line 158) | function normalizeRule(rule: HarnessPolicyRule): HarnessPolicyRule {
  function isLegacyEnforcementInput (line 180) | function isLegacyEnforcementInput(
  constant CORE_DIRECTORY_CANDIDATES (line 186) | const CORE_DIRECTORY_CANDIDATES = [
  constant ROOT_CONFIG_FILE_CANDIDATES (line 207) | const ROOT_CONFIG_FILE_CANDIDATES = [
  constant ROOT_SOURCE_FILE_EXTENSIONS (line 234) | const ROOT_SOURCE_FILE_EXTENSIONS = new Set([
  constant CONFIG_DIRECTORY_PATTERNS (line 252) | const CONFIG_DIRECTORY_PATTERNS: Array<{ path: string; pattern: string }...
  class HarnessPolicyService (line 266) | class HarnessPolicyService {
    method constructor (line 267) | constructor(private readonly options: HarnessPolicyServiceOptions) {}
    method repoPath (line 269) | private get repoPath(): string {
    method policyPath (line 273) | private get policyPath(): string {
    method toEvaluationInput (line 277) | private toEvaluationInput(
    method loadPolicy (line 295) | async loadPolicy(): Promise<HarnessPolicyDocument> {
    method savePolicy (line 312) | async savePolicy(policy: HarnessPolicyDocument): Promise<HarnessPolicy...
    method listRules (line 323) | async listRules(): Promise<HarnessPolicyRule[]> {
    method evaluateWithPolicy (line 328) | private evaluateWithPolicy(input: HarnessPolicyEvaluationInput, policy...
    method evaluate (line 397) | async evaluate(input: HarnessPolicyEvaluationInput, policy?: HarnessPo...
    method evaluateAndAuthorize (line 402) | async evaluateAndAuthorize(
    method authorize (line 410) | async authorize(
    method enforce (line 430) | async enforce(
    method setPolicyFromRules (line 437) | async setPolicyFromRules(input: {
    method setPolicy (line 448) | async setPolicy(policy: HarnessPolicyDocument): Promise<HarnessPolicyD...
    method setPolicyDocument (line 456) | async setPolicyDocument(policy: HarnessPolicyDocument): Promise<Harnes...
    method registerRule (line 460) | async registerRule(input: CreateHarnessPolicyRuleInput): Promise<Harne...
    method evaluateLegacy (line 476) | async evaluateLegacy(input: HarnessPolicyEvaluationInput): Promise<Har...
    method assertAllowed (line 480) | async assertAllowed(input: HarnessPolicyEvaluationInput): Promise<void> {
    method evaluatePolicy (line 495) | async evaluatePolicy(input: HarnessPolicyEvaluationInput): Promise<Har...
    method evaluateRule (line 499) | async evaluateRule(input: HarnessPolicyEvaluationInput): Promise<Harne...
    method getPolicy (line 503) | async getPolicy(): Promise<HarnessPolicyDocument> {
    method detectStackInfo (line 507) | private async detectStackInfo(): Promise<StackInfo | undefined> {
    method readTopLevelEntries (line 515) | private async readTopLevelEntries(): Promise<{ files: string[]; direct...
    method getCorePathPatterns (line 543) | private getCorePathPatterns(topLevelEntries: { files: string[]; direct...
    method getConfigPathPatterns (line 558) | private async getConfigPathPatterns(topLevelEntries: { files: string[]...
    method buildCoreRuleReason (line 582) | private buildCoreRuleReason(stackInfo?: StackInfo): string {
    method createBootstrapPolicy (line 596) | async createBootstrapPolicy(

FILE: src/services/harness/replayService.ts
  type HarnessReplayEventSource (line 20) | type HarnessReplayEventSource =
  type HarnessReplayEvent (line 29) | interface HarnessReplayEvent {
  type HarnessReplayRecord (line 38) | interface HarnessReplayRecord {
  type HarnessReplayServiceOptions (line 57) | interface HarnessReplayServiceOptions {
  type ReplaySessionOptions (line 62) | interface ReplaySessionOptions {
  type HarnessReplayDependencies (line 67) | interface HarnessReplayDependencies {
  function nowIso (line 73) | function nowIso(): string {
  function sortByCreatedAt (line 77) | function sortByCreatedAt<T extends { createdAt: string }>(items: T[]): T...
  class HarnessReplayService (line 81) | class HarnessReplayService {
    method constructor (line 86) | constructor(private readonly options: HarnessReplayServiceOptions) {
    method repoPath (line 102) | private get repoPath(): string {
    method replaysPath (line 106) | private get replaysPath(): string {
    method replayFile (line 110) | private replayFile(replayId: string): string {
    method ensureLayout (line 114) | private async ensureLayout(): Promise<void> {
    method saveReplay (line 118) | private async saveReplay(replay: HarnessReplayRecord): Promise<void> {
    method readReplay (line 123) | private async readReplay(replayId: string): Promise<HarnessReplayRecor...
    method buildReplay (line 132) | async buildReplay(
    method replaySession (line 273) | async replaySession(
    method listReplays (line 282) | async listReplays(filter?: { sessionId?: string }): Promise<HarnessRep...
    method getReplay (line 298) | async getReplay(replayId: string): Promise<HarnessReplayRecord> {

FILE: src/services/harness/runtimeStateService.ts
  type HarnessSessionStatus (line 12) | type HarnessSessionStatus = 'active' | 'paused' | 'completed' | 'failed';
  type HarnessTraceLevel (line 13) | type HarnessTraceLevel = 'debug' | 'info' | 'warn' | 'error';
  type HarnessArtifactKind (line 14) | type HarnessArtifactKind = 'text' | 'json' | 'file';
  type HarnessRuntimeStateServiceOptions (line 16) | interface HarnessRuntimeStateServiceOptions {
  type HarnessSessionCheckpoint (line 20) | interface HarnessSessionCheckpoint {
  type HarnessSessionRecord (line 28) | interface HarnessSessionRecord {
  type HarnessTraceRecord (line 47) | interface HarnessTraceRecord {
  type HarnessArtifactRecord (line 57) | interface HarnessArtifactRecord {
  type HarnessRuntimeStatePort (line 68) | interface HarnessRuntimeStatePort {
  type CreateSessionInput (line 79) | interface CreateSessionInput {
  type AppendTraceInput (line 84) | interface AppendTraceInput {
  type AddArtifactInput (line 91) | interface AddArtifactInput {
  type CheckpointInput (line 99) | interface CheckpointInput {
  function nowIso (line 106) | function nowIso(): string {
  function normalizeContent (line 110) | function normalizeContent(content: unknown): unknown {
  class HarnessRuntimeStateService (line 122) | class HarnessRuntimeStateService {
    method constructor (line 123) | constructor(private readonly options: HarnessRuntimeStateServiceOption...
    method repoPath (line 125) | private get repoPath(): string {
    method contextPath (line 129) | private get contextPath(): string {
    method harnessPath (line 133) | private get harnessPath(): string {
    method sessionsPath (line 137) | private get sessionsPath(): string {
    method tracesPath (line 141) | private get tracesPath(): string {
    method artifactsPath (line 145) | private get artifactsPath(): string {
    method sessionFile (line 149) | private sessionFile(sessionId: string): string {
    method traceFile (line 153) | private traceFile(sessionId: string): string {
    method artifactFile (line 157) | private artifactFile(sessionId: string, artifactId: string): string {
    method ensureLayout (line 161) | private async ensureLayout(): Promise<void> {
    method readSession (line 167) | private async readSession(sessionId: string): Promise<HarnessSessionRe...
    method saveSession (line 176) | private async saveSession(session: HarnessSessionRecord): Promise<void> {
    method appendTraceLine (line 181) | private async appendTraceLine(sessionId: string, trace: HarnessTraceRe...
    method recordTrace (line 186) | private async recordTrace(sessionId: string, trace: HarnessTraceRecord...
    method createSession (line 198) | async createSession(input: CreateSessionInput): Promise<HarnessSession...
    method listSessions (line 229) | async listSessions(): Promise<HarnessSessionRecord[]> {
    method getSession (line 241) | async getSession(sessionId: string): Promise<HarnessSessionRecord> {
    method appendTrace (line 245) | async appendTrace(sessionId: string, input: AppendTraceInput): Promise...
    method addArtifact (line 260) | async addArtifact(sessionId: string, input: AddArtifactInput): Promise...
    method listCheckpoints (line 297) | async listCheckpoints(sessionId: string): Promise<HarnessSessionCheckp...
    method listArtifacts (line 302) | async listArtifacts(sessionId: string): Promise<HarnessArtifactRecord[...
    method listTraces (line 318) | async listTraces(sessionId: string): Promise<HarnessTraceRecord[]> {
    method checkpointSession (line 332) | async checkpointSession(sessionId: string, input: CheckpointInput = {}...
    method resumeSession (line 367) | async resumeSession(sessionId: string): Promise<HarnessSessionRecord> {
    method completeSession (line 390) | async completeSession(sessionId: string, note?: string): Promise<Harne...
    method failSession (line 408) | async failSession(sessionId: string, message: string): Promise<Harness...

FILE: src/services/harness/sensorCatalogService.ts
  type HarnessSensorCatalogSeverity (line 12) | type HarnessSensorCatalogSeverity = 'critical' | 'warning' | 'info';
  type HarnessShellSensorConfig (line 14) | interface HarnessShellSensorConfig {
  type HarnessSensorCatalogDocument (line 25) | interface HarnessSensorCatalogDocument {
  type HarnessSensorCatalogServiceOptions (line 40) | interface HarnessSensorCatalogServiceOptions {
  class HarnessSensorCatalogService (line 45) | class HarnessSensorCatalogService {
    method constructor (line 46) | constructor(private readonly options: HarnessSensorCatalogServiceOptio...
    method repoPath (line 48) | private get repoPath(): string {
    method contextPath (line 52) | private get contextPath(): string {
    method configPath (line 58) | get configPath(): string {
    method bootstrap (line 62) | async bootstrap(force: boolean = false): Promise<HarnessSensorCatalogD...
    method load (line 82) | async load(): Promise<HarnessSensorCatalogDocument | null> {
    method loadSync (line 90) | loadSync(): HarnessSensorCatalogDocument | null {
    method resolveEffectiveSensorsSync (line 98) | resolveEffectiveSensorsSync(): HarnessShellSensorConfig[] {
    method detectSensorsSync (line 109) | detectSensorsSync(): HarnessShellSensorConfig[] {
    method detectNodeSensors (line 261) | private detectNodeSensors(packageJsonPath: string): HarnessShellSensor...
    method serializeStack (line 323) | private serializeStack(stack: StackInfo): HarnessSensorCatalogDocument...

FILE: src/services/harness/sensorsService.ts
  type HarnessSensorSeverity (line 15) | type HarnessSensorSeverity = 'info' | 'warning' | 'critical';
  type HarnessSensorStatus (line 16) | type HarnessSensorStatus = 'passed' | 'failed' | 'skipped' | 'blocked';
  type HarnessSensorExecutionInput (line 18) | interface HarnessSensorExecutionInput {
  type HarnessSensorExecutionResult (line 25) | interface HarnessSensorExecutionResult {
  type HarnessSensorDefinition (line 33) | interface HarnessSensorDefinition {
  type HarnessSensorRun (line 42) | interface HarnessSensorRun extends HarnessSensorExecutionResult {
  type HarnessBackpressurePolicy (line 53) | interface HarnessBackpressurePolicy {
  type HarnessBackpressureResult (line 58) | interface HarnessBackpressureResult {
  type HarnessSensorsServiceOptions (line 64) | interface HarnessSensorsServiceOptions {
  class HarnessSensorsService (line 68) | class HarnessSensorsService {
    method constructor (line 71) | constructor(private readonly options: HarnessSensorsServiceOptions) {}
    method registerSensor (line 73) | registerSensor(definition: HarnessSensorDefinition): HarnessSensorDefi...
    method listSensors (line 78) | listSensors(): HarnessSensorDefinition[] {
    method getSensor (line 82) | getSensor(sensorId: string): HarnessSensorDefinition | undefined {
    method runSensor (line 86) | async runSensor(
    method getSessionSensorRuns (line 125) | async getSessionSensorRuns(sessionId: string): Promise<HarnessSensorRu...
    method evaluateBackpressure (line 132) | evaluateBackpressure(

FILE: src/services/harness/skillsService.ts
  type HarnessSkillsServiceOptions (line 15) | interface HarnessSkillsServiceOptions {
  function getSkillFillInstructions (line 19) | function getSkillFillInstructions(skillSlug: string): string {
  function buildSkillFillPrompt (line 87) | function buildSkillFillPrompt(
  class HarnessSkillsService (line 141) | class HarnessSkillsService {
    method constructor (line 142) | constructor(private readonly options: HarnessSkillsServiceOptions) {}
    method repoPath (line 144) | private get repoPath(): string {
    method getRegistry (line 148) | private getRegistry() {
    method list (line 153) | async list(includeContent?: boolean): Promise<Record<string, unknown>> {
    method getContent (line 179) | async getContent(skillSlug: string): Promise<Record<string, unknown>> {
    method getForPhase (line 206) | async getForPhase(phase: PrevcPhase): Promise<Record<string, unknown>> {
    method scaffold (line 225) | async scaffold(params: {
    method export (line 242) | async export(params: {
    method fill (line 268) | async fill(params: {

FILE: src/services/harness/taskContractsService.ts
  type HarnessTaskContractStatus (line 18) | type HarnessTaskContractStatus =
  type HarnessTaskContract (line 26) | interface HarnessTaskContract {
  type HarnessHandoffContract (line 43) | interface HarnessHandoffContract {
  type HarnessTaskCompletionResult (line 55) | interface HarnessTaskCompletionResult {
  type HarnessTaskContractsServiceOptions (line 66) | interface HarnessTaskContractsServiceOptions {
  class HarnessTaskContractsService (line 71) | class HarnessTaskContractsService {
    method constructor (line 72) | constructor(private readonly options: HarnessTaskContractsServiceOptio...
    method contractsPath (line 74) | private get contractsPath(): string {
    method tasksPath (line 78) | private get tasksPath(): string {
    method handoffsPath (line 82) | private get handoffsPath(): string {
    method ensureLayout (line 86) | private async ensureLayout(): Promise<void> {
    method taskFile (line 93) | private async taskFile(taskId: string): Promise<string> {
    method handoffFile (line 98) | private async handoffFile(handoffId: string): Promise<string> {
    method createTaskContract (line 103) | async createTaskContract(input: {
    method listTaskContracts (line 148) | async listTaskContracts(): Promise<HarnessTaskContract[]> {
    method getTaskContract (line 160) | async getTaskContract(taskId: string): Promise<HarnessTaskContract | n...
    method updateTaskContract (line 169) | async updateTaskContract(
    method createHandoffContract (line 188) | async createHandoffContract(input: {
    method listHandoffContracts (line 223) | async listHandoffContracts(): Promise<HarnessHandoffContract[]> {
    method evaluateTaskCompletion (line 235) | async evaluateTaskCompletion(taskId: string, sessionId?: string): Prom...

FILE: src/services/harness/workflowStateService.ts
  type HarnessWorkflowStateServiceOptions (line 13) | interface HarnessWorkflowStateServiceOptions {
  type WorkflowHarnessBinding (line 17) | interface WorkflowHarnessBinding {
  type HarnessWorkflowRecord (line 25) | interface HarnessWorkflowRecord {
  class HarnessWorkflowStateService (line 33) | class HarnessWorkflowStateService {
    method constructor (line 34) | constructor(private readonly options: HarnessWorkflowStateServiceOptio...
    method contextPath (line 36) | private get contextPath(): string {
    method workflowsPath (line 40) | private get workflowsPath(): string {
    method currentPath (line 44) | private get currentPath(): string {
    method archivePath (line 48) | private get archivePath(): string {
    method legacyBindingPath (line 52) | private get legacyBindingPath(): string {
    method ensureLayout (line 56) | private async ensureLayout(): Promise<void> {
    method normalizeBinding (line 60) | private normalizeBinding(value: unknown): WorkflowHarnessBinding | null {
    method normalizeRecord (line 90) | private normalizeRecord(
    method readLegacyBinding (line 110) | private async readLegacyBinding(): Promise<WorkflowHarnessBinding | nu...
    method readLegacyBindingSync (line 123) | private readLegacyBindingSync(): WorkflowHarnessBinding | null {
    method writeRecord (line 136) | private async writeRecord(record: HarnessWorkflowRecord): Promise<void> {
    method exists (line 144) | async exists(): Promise<boolean> {
    method loadRecord (line 148) | async loadRecord(): Promise<HarnessWorkflowRecord> {
    method load (line 164) | async load(): Promise<PrevcStatus> {
    method loadRecordSync (line 169) | loadRecordSync(): HarnessWorkflowRecord {
    method loadSync (line 175) | loadSync(): PrevcStatus {
    method save (line 180) | async save(status: PrevcStatus): Promise<void> {
    method getBinding (line 194) | async getBinding(): Promise<WorkflowHarnessBinding | null> {
    method saveBinding (line 202) | async saveBinding(binding: WorkflowHarnessBinding | null): Promise<voi...
    method remove (line 213) | async remove(): Promise<void> {
    method archive (line 222) | async archive(name: string): Promise<void> {

FILE: src/services/import/agentsDetector.ts
  function normalizeAgentFilename (line 7) | function normalizeAgentFilename(filePath: string): string {
  function normalizeAgentName (line 11) | function normalizeAgentName(filePath: string): string {
  class AgentsDetector (line 15) | class AgentsDetector {
    method detectAgents (line 19) | async detectAgents(repoPath: string, autoDetect: boolean = true): Prom...
    method detectFromPaths (line 108) | async detectFromPaths(sourcePaths: string[], repoPath: string): Promis...

FILE: src/services/import/importAgentsService.ts
  class ImportAgentsService (line 16) | class ImportAgentsService {
    method constructor (line 22) | constructor(dependencies: ImportServiceDependencies) {
    method run (line 29) | async run(rawOptions: ImportAgentsCommandFlags, repoPath: string = pro...
    method resolveOptions (line 82) | private async resolveOptions(
    method importFiles (line 103) | private async importFiles(
    method displayConfig (line 175) | private displayConfig(options: ImportAgentsOptions): void {
    method displaySummary (line 194) | private displaySummary(result: ImportResult, dryRun: boolean): void {

FILE: src/services/import/importRulesService.ts
  class ImportRulesService (line 17) | class ImportRulesService {
    method constructor (line 23) | constructor(dependencies: ImportServiceDependencies) {
    method run (line 30) | async run(rawOptions: ImportRulesCommandFlags, repoPath: string = proc...
    method resolveOptions (line 83) | private async resolveOptions(
    method importFiles (line 106) | private async importFiles(
    method formatContent (line 181) | private formatContent(content: string, file: RuleFileInfo, format: Imp...
    method formatAsMarkdown (line 193) | private formatAsMarkdown(content: string, file: RuleFileInfo): string {
    method formatAsFormatted (line 202) | private formatAsFormatted(content: string, file: RuleFileInfo): string {
    method displayConfig (line 207) | private displayConfig(options: ImportRulesOptions): void {
    method displaySummary (line 227) | private displaySummary(result: ImportResult, dryRun: boolean): void {

FILE: src/services/import/presets.ts
  function buildRuleSources (line 15) | function buildRuleSources(): RuleSource[] {
  function buildAgentSources (line 32) | function buildAgentSources(): RuleSource[] {
  constant RULE_SOURCES (line 39) | const RULE_SOURCES: RuleSource[] = buildRuleSources();
  constant AGENT_SOURCES (line 44) | const AGENT_SOURCES: RuleSource[] = buildAgentSources();
  function getRuleSourceByName (line 46) | function getRuleSourceByName(name: string): RuleSource | undefined {
  function getAgentSourceByName (line 50) | function getAgentSourceByName(name: string): RuleSource | undefined {
  function getAllRuleSourceNames (line 54) | function getAllRuleSourceNames(): string[] {
  function getAllAgentSourceNames (line 58) | function getAllAgentSourceNames(): string[] {

FILE: src/services/import/rulesDetector.ts
  class RulesDetector (line 7) | class RulesDetector {
    method detectRules (line 11) | async detectRules(repoPath: string, autoDetect: boolean = true): Promi...
    method detectFromPaths (line 107) | async detectFromPaths(sourcePaths: string[], repoPath: string): Promis...
    method findFilesInDirectory (line 168) | private async findFilesInDirectory(dirPath: string, patterns: string[]...
    method determineRuleType (line 187) | private determineRuleType(sourceName: string): RuleType {
    method determineRuleTypeFromPath (line 203) | private determineRuleTypeFromPath(filePath: string): RuleType {
    method generateTargetFilename (line 220) | private generateTargetFilename(sourcePath: string, type: RuleType): st...

FILE: src/services/import/types.ts
  type RuleType (line 4) | type RuleType =
  type ImportFormat (line 19) | type ImportFormat = 'markdown' | 'raw' | 'formatted';
  type RuleFileInfo (line 21) | interface RuleFileInfo {
  type ImportRulesCommandFlags (line 30) | interface ImportRulesCommandFlags {
  type ImportAgentsCommandFlags (line 40) | interface ImportAgentsCommandFlags {
  type ImportServiceDependencies (line 49) | interface ImportServiceDependencies {
  type ImportRulesOptions (line 55) | interface ImportRulesOptions {
  type ImportAgentsOptions (line 65) | interface ImportAgentsOptions {
  type ImportResult (line 74) | interface ImportResult {
  type DetectionResult (line 82) | interface DetectionResult {
  type RuleSource (line 87) | interface RuleSource {

FILE: src/services/mcp/actionLogger.ts
  type ActionStatus (line 14) | type ActionStatus = 'success' | 'error';
  type MCPActionLogEntry (line 16) | interface MCPActionLogEntry {
  constant SENSITIVE_KEYS (line 25) | const SENSITIVE_KEYS = new Set([
  constant MAX_DEPTH (line 37) | const MAX_DEPTH = 4;
  constant MAX_ARRAY (line 38) | const MAX_ARRAY = 20;
  constant MAX_STRING (line 39) | const MAX_STRING = 200;
  constant MCP_ACTIVITY_NAME (line 40) | const MCP_ACTIVITY_NAME = 'mcp-activity';
  function resolveContextPath (line 44) | async function resolveContextPath(repoPath: string): Promise<string> {
  function sanitizeValue (line 52) | function sanitizeValue(value: unknown, depth: number = 0): unknown {
  function sanitizeDetails (line 88) | function sanitizeDetails(details?: Record<string, unknown>): Record<stri...
  function resolveWorkflowSessionId (line 93) | async function resolveWorkflowSessionId(contextPath: string): Promise<st...
  function resolveMcpActivitySessionId (line 107) | async function resolveMcpActivitySessionId(
  function logMcpAction (line 142) | async function logMcpAction(

FILE: src/services/mcp/gateway/agent.ts
  type AgentOptions (line 18) | interface AgentOptions {
  function handleAgent (line 25) | async function handleAgent(

FILE: src/services/mcp/gateway/context.test.ts
  function parseResponse (line 8) | function parseResponse(response: { content: Array<{ text: string }> }) {

FILE: src/services/mcp/gateway/context.ts
  type ContextOptions (line 18) | interface ContextOptions {
  function handleContext (line 26) | async function handleContext(

FILE: src/services/mcp/gateway/explore.ts
  type ExploreOptions (line 21) | interface ExploreOptions {
  function handleExplore (line 28) | async function handleExplore(

FILE: src/services/mcp/gateway/harness.ts
  type HarnessOptions (line 13) | interface HarnessOptions {
  function normalizePolicyEffect (line 17) | function normalizePolicyEffect(effect?: string): HarnessPolicyEffect {
  function normalizePolicyTarget (line 29) | function normalizePolicyTarget(target?: string, pathPattern?: string, ri...
  function handleHarness (line 45) | async function handleHarness(

FILE: src/services/mcp/gateway/metrics.ts
  type SessionMetrics (line 11) | interface SessionMetrics {
  type MetricsSummary (line 26) | interface MetricsSummary {
  class MetricsStore (line 38) | class MetricsStore {
    method constructor (line 41) | constructor() {
    method createNewSession (line 45) | private createNewSession(): SessionMetrics {
    method recordContextQuery (line 59) | recordContextQuery(type: 'qa' | 'flow' | 'pattern' | 'other'): void {
    method recordFileRead (line 76) | recordFileRead(estimatedTokens: number = 1000): void {
    method getMetrics (line 82) | getMetrics(): SessionMetrics {
    method getSummary (line 86) | getSummary(): MetricsSummary {
    method reset (line 136) | reset(): void {
  function recordContextQuery (line 147) | function recordContextQuery(type: 'qa' | 'flow' | 'pattern' | 'other'): ...
  function recordFileRead (line 154) | function recordFileRead(estimatedTokens?: number): void {
  function getMetrics (line 161) | function getMetrics(): SessionMetrics {
  function getMetricsSummary (line 168) | function getMetricsSummary(): MetricsSummary {
  function resetMetrics (line 175) | function resetMetrics(): void {
  function handleMetricsAction (line 182) | function handleMetricsAction(action: 'get' | 'summary' | 'reset'): object {

FILE: src/services/mcp/gateway/plan.ts
  type PlanOptions (line 16) | interface PlanOptions {
  function handlePlan (line 23) | async function handlePlan(

FILE: src/services/mcp/gateway/response.ts
  type MCPToolResponse (line 11) | interface MCPToolResponse {
  function createJsonResponse (line 27) | function createJsonResponse(data: unknown): MCPToolResponse {
  function createErrorResponse (line 39) | function createErrorResponse(error: unknown): MCPToolResponse {
  function createTextResponse (line 55) | function createTextResponse(text: string): MCPToolResponse {
  function createScaffoldResponse (line 68) | function createScaffoldResponse(
  function buildEnhancementPrompt (line 123) | function buildEnhancementPrompt(pendingFiles: string[], repoPath?: strin...

FILE: src/services/mcp/gateway/skill.ts
  type SkillOptions (line 15) | interface SkillOptions {
  function handleSkill (line 22) | async function handleSkill(

FILE: src/services/mcp/gateway/sync.ts
  type SyncOptions (line 21) | interface SyncOptions {
  function handleSync (line 28) | async function handleSync(

FILE: src/services/mcp/gateway/types.ts
  type ExploreAction (line 16) | type ExploreAction = 'read' | 'list' | 'analyze' | 'search' | 'getStruct...
  type ContextAction (line 17) | type ContextAction = 'check' | 'bootstrapStatus' | 'init' | 'fill' | 'fi...
  type SyncAction (line 18) | type SyncAction = 'exportRules' | 'exportDocs' | 'exportAgents' | 'expor...
  type PlanAction (line 19) | type PlanAction = 'link' | 'getLinked' | 'getDetails' | 'getForPhase' | ...
  type AgentAction (line 20) | type AgentAction = 'discover' | 'getInfo' | 'orchestrate' | 'getSequence...
  type SkillAction (line 21) | type SkillAction = 'list' | 'getContent' | 'getForPhase' | 'scaffold' | ...
  type HarnessAction (line 22) | type HarnessAction =
  type ExploreParams (line 56) | interface ExploreParams {
  type ContextParams (line 71) | interface ContextParams {
  type SyncParams (line 107) | interface SyncParams {
  type PlanParams (line 128) | interface PlanParams {
  type AgentParams (line 146) | interface AgentParams {
  type SkillParams (line 157) | interface SkillParams {
  type HarnessParams (line 167) | interface HarnessParams {

FILE: src/services/mcp/gateway/workflowAdvance.ts
  type WorkflowAdvanceParams (line 19) | interface WorkflowAdvanceParams {
  type WorkflowAdvanceOptions (line 25) | interface WorkflowAdvanceOptions {
  function handleWorkflowAdvance (line 38) | async function handleWorkflowAdvance(

FILE: src/services/mcp/gateway/workflowInit.ts
  type WorkflowInitParams (line 19) | interface WorkflowInitParams {
  type WorkflowInitOptions (line 30) | interface WorkflowInitOptions {
  function handleWorkflowInit (line 40) | async function handleWorkflowInit(
  function buildWorkflowEnhancementPrompt (line 123) | function buildWorkflowEnhancementPrompt(options: {
  function buildWorkflowNextSteps (line 199) | function buildWorkflowNextSteps(options: {

FILE: src/services/mcp/gateway/workflowManage.test.ts
  function parseResponse (line 10) | function parseResponse(response: { content: Array<{ text: string }> }) {

FILE: src/services/mcp/gateway/workflowManage.ts
  type WorkflowManageParams (line 20) | interface WorkflowManageParams {
  type WorkflowManageOptions (line 53) | interface WorkflowManageOptions {
  function handleWorkflowManage (line 60) | async function handleWorkflowManage(

FILE: src/services/mcp/gateway/workflowStatus.test.ts
  function parseResponse (line 9) | function parseResponse(response: { content: Array<{ text: string }> }) {

FILE: src/services/mcp/gateway/workflowStatus.ts
  type WorkflowStatusParams (line 18) | interface WorkflowStatusParams {
  type WorkflowStatusOptions (line 22) | interface WorkflowStatusOptions {
  function handleWorkflowStatus (line 29) | async function handleWorkflowStatus(

FILE: src/services/mcp/mcpServer.ts
  type MCPServerOptions (line 56) | interface MCPServerOptions {
  class AIContextMCPServer (line 67) | class AIContextMCPServer {
    method constructor (line 76) | constructor(options: MCPServerOptions = {}) {
    method registerGatewayTools (line 107) | private registerGatewayTools(): void {
    method registerResources (line 730) | private registerResources(): void {
    method registerWorkflowResources (line 821) | private registerWorkflowResources(): void {
    method initializeRepoPath (line 891) | private async initializeRepoPath(): Promise<void> {
    method findProjectRoot (line 909) | private async findProjectRoot(startPath: string): Promise<string | nul...
    method cacheRepoPathIfValid (line 932) | private cacheRepoPathIfValid(repoPath: string): void {
    method getRepoPath (line 949) | private getRepoPath(paramsRepoPath?: string): string {
    method wrapWithActionLogging (line 972) | private wrapWithActionLogging<TParams>(
    method validatePathParams (line 1013) | private validatePathParams<TParams>(params: TParams, repoPath: string)...
    method logToolResponse (line 1025) | private async logToolResponse<TParams>(
    method logToolError (line 1051) | private async logToolError<TParams>(
    method parseResponsePayload (line 1069) | private parseResponsePayload(response: MCPToolResponse): Record<string...
    method buildResultSummary (line 1080) | private buildResultSummary(payload: Record<string, unknown>): Record<s...
    method start (line 1107) | async start(): Promise<void> {
    method stop (line 1116) | async stop(): Promise<void> {
    method log (line 1125) | private log(message: string): void {
  function startMCPServer (line 1135) | async function startMCPServer(options: MCPServerOptions = {}): Promise<A...

FILE: src/services/qa/patternInferer.ts
  class PatternInferer (line 12) | class PatternInferer {
    method inferFromMap (line 13) | inferFromMap(map: CodebaseMap): DetectedFunctionalPatterns {

FILE: src/services/qa/qaService.ts
  type QAEntry (line 23) | interface QAEntry {
  type QASearchResult (line 35) | interface QASearchResult {
  type QAGenerationResult (line 44) | interface QAGenerationResult {
  class QAService (line 53) | class QAService {
    method constructor (line 59) | constructor(options?: { useLSP?: boolean }) {
    method generateFromCodebase (line 72) | async generateFromCodebase(repoPath: string): Promise<QAGenerationResu...
    method search (line 126) | async search(repoPath: string, query: string): Promise<QASearchResult[...
    method getAll (line 171) | async getAll(repoPath: string): Promise<QAEntry[]> {
    method getBySlug (line 201) | async getBySlug(repoPath: string, slug: string): Promise<QAEntry | nul...
    method generateQAForTopic (line 219) | private async generateQAForTopic(
    method generateGettingStartedAnswer (line 321) | private generateGettingStartedAnswer(stack: StackInfo, repoPath: strin...
    method generateProjectStructureAnswer (line 400) | private async generateProjectStructureAnswer(repoPath: string, stack: ...
    method generateCLICommandsAnswer (line 447) | private generateCLICommandsAnswer(stack: StackInfo): string {
    method generateCLIArgumentsAnswer (line 468) | private generateCLIArgumentsAnswer(stack: StackInfo): string {
    method generateRoutingAnswer (line 489) | private async generateRoutingAnswer(
    method generateMiddlewareAnswer (line 538) | private async generateMiddlewareAnswer(
    method generateAuthAnswer (line 564) | private generateAuthAnswer(patterns: DetectedFunctionalPatterns): stri...
    method generateDatabaseAnswer (line 582) | private generateDatabaseAnswer(patterns: DetectedFunctionalPatterns): ...
    method generateAPIEndpointsAnswer (line 600) | private async generateAPIEndpointsAnswer(
    method generateTestingAnswer (line 623) | private generateTestingAnswer(stack: StackInfo, patterns: DetectedFunc...
    method generateErrorHandlingAnswer (line 651) | private generateErrorHandlingAnswer(patterns: DetectedFunctionalPatter...
    method generateCachingAnswer (line 669) | private generateCachingAnswer(patterns: DetectedFunctionalPatterns): s...
    method generateRealtimeAnswer (line 687) | private generateRealtimeAnswer(patterns: DetectedFunctionalPatterns): ...
    method generateBackgroundJobsAnswer (line 705) | private generateBackgroundJobsAnswer(patterns: DetectedFunctionalPatte...
    method generateDeploymentAnswer (line 723) | private generateDeploymentAnswer(stack: StackInfo): string {
    method getPatternFiles (line 747) | private getPatternFiles(patterns: DetectedFunctionalPatterns, type: st...
    method findRelevantFiles (line 756) | private async findRelevantFiles(repoPath: string, patterns: string[]):...
    method saveQAEntries (line 787) | private async saveQAEntries(
    method formatQAEntry (line 806) | private formatQAEntry(entry: QAEntry): string {
    method generateQAReadme (line 827) | private generateQAReadme(entries: QAEntry[], topicResult: TopicDetecti...
    method parseQAEntry (line 854) | private parseQAEntry(content: string, filename: string): QAEntry | null {
    method calculateRelevance (line 902) | private calculateRelevance(
    method convertMapStackToStackInfo (line 955) | private convertMapStackToStackInfo(map: CodebaseMap): StackInfo {
    method shutdown (line 977) | async shutdown(): Promise<void> {

FILE: src/services/qa/topicDetector.ts
  type QATopic (line 16) | interface QATopic {
  type TopicDetectionResult (line 26) | interface TopicDetectionResult {
  type ProjectType (line 32) | type ProjectType =
  class TopicDetector (line 45) | class TopicDetector {
    method detectTopics (line 49) | detectTopics(
    method detectProjectType (line 313) | private detectProjectType(stack: StackInfo): ProjectType {
    method isCLI (line 364) | private isCLI(stack: StackInfo): boolean {
    method hasWebFramework (line 375) | private hasWebFramework(stack: StackInfo): boolean {
    method hasFrontendFramework (line 398) | private hasFrontendFramework(stack: StackInfo): boolean {

FILE: src/services/quickSync/quickSyncService.ts
  type QuickSyncServiceDependencies (line 17) | interface QuickSyncServiceDependencies {
  type QuickSyncOptions (line 23) | interface QuickSyncOptions {
  type QuickSyncResult (line 51) | interface QuickSyncResult {
  class QuickSyncService (line 58) | class QuickSyncService {
    method constructor (line 63) | constructor(deps: QuickSyncServiceDependencies) {
    method run (line 72) | async run(repoPath: string, options: QuickSyncOptions = {}): Promise<Q...
    method getStats (line 242) | async getStats(repoPath: string): Promise<{
  function createQuickSyncService (line 297) | function createQuickSyncService(deps: QuickSyncServiceDependencies): Qui...

FILE: src/services/report/reportService.ts
  type ReportServiceDependencies (line 25) | type ReportServiceDependencies = BaseDependencies;
  type ReportOptions (line 27) | interface ReportOptions {
  type WorkflowReport (line 35) | interface WorkflowReport {
  type PhaseReport (line 55) | interface PhaseReport {
  type RoleReport (line 65) | interface RoleReport {
  type TimelineEvent (line 72) | interface TimelineEvent {
  type StackReport (line 79) | interface StackReport {
  class ReportService (line 86) | class ReportService {
    method constructor (line 87) | constructor(private deps: ReportServiceDependencies) {}
    method generate (line 92) | async generate(repoPath: string, options: ReportOptions = {}): Promise...
    method output (line 134) | async output(report: WorkflowReport, options: ReportOptions = {}): Pro...
    method createWorkflowService (line 148) | private createWorkflowService(repoPath: string): WorkflowService {
    method detectStack (line 161) | private async detectStack(repoPath: string): Promise<StackReport> {
    method buildPhasesReport (line 175) | private buildPhasesReport(status: PrevcStatus): PhaseReport[] {
    method buildRolesForPhase (line 190) | private buildRolesForPhase(status: PrevcStatus, phase: string): RoleRe...
    method mapOutputs (line 204) | private mapOutputs(outputs?: Array<{ path: string } | string>): string...
    method buildTimeline (line 211) | private buildTimeline(status: PrevcStatus): TimelineEvent[] {
    method outputJson (line 247) | private async outputJson(report: WorkflowReport, options: ReportOption...
    method outputMarkdown (line 255) | private async outputMarkdown(report: WorkflowReport, options: ReportOp...
    method writeOutput (line 263) | private async writeOutput(content: string, options: ReportOptions): Pr...
    method outputConsole (line 275) | private outputConsole(report: WorkflowReport): void {
    method generateVisualDashboard (line 282) | generateVisualDashboard(report: WorkflowReport): string {
    method getStatusIcon (line 333) | private getStatusIcon(status: string): string {
    method getStatusLabel (line 343) | private getStatusLabel(status: string): string {
    method centerText (line 353) | private centerText(text: string, width: number): string {
    method padText (line 359) | private padText(text: string, width: number): string {
    method generateMarkdown (line 366) | private generateMarkdown(report: WorkflowReport): string {
    method generateSummaryTable (line 382) | private generateSummaryTable(report: WorkflowReport): string {
    method generatePhasesSection (line 396) | private generatePhasesSection(phases: PhaseReport[]): string {
    method generateTimelineSection (line 412) | private generateTimelineSection(timeline: TimelineEvent[]): string {
    method generateStackSection (line 422) | private generateStackSection(stack: StackReport): string {
    method generateRecommendationsSection (line 434) | private generateRecommendationsSection(recommendations: string[]): str...

FILE: src/services/reverseSync/importSkillsService.ts
  type ImportSkillsResult (line 26) | interface ImportSkillsResult {
  class ImportSkillsService (line 41) | class ImportSkillsService {
    method constructor (line 47) | constructor(dependencies: ReverseSyncServiceDependencies) {
    method run (line 54) | async run(
    method importSkillFiles (line 103) | async importSkillFiles(
    method resolveOptions (line 110) | private async resolveOptions(
    method importFiles (line 133) | private async importFiles(
    method importSingleSkill (line 216) | private async importSingleSkill(
    method prepareContent (line 271) | private async prepareContent(
    method addImportMetadata (line 285) | private addImportMetadata(content: string, skill: SkillFileInfo): stri...
    method mergeContent (line 333) | private async mergeContent(
    method getRenamedPath (line 357) | private async getRenamedPath(originalPath: string, sourceTool: string)...
    method logImportAction (line 381) | private logImportAction(
    method displaySummary (line 408) | private displaySummary(result: ImportSkillsResult, dryRun: boolean): v...
    method createEmptyResult (line 443) | private createEmptyResult(targetPath: string): ImportSkillsResult {

FILE: src/services/reverseSync/presets.ts
  constant SKILL_SOURCES (line 28) | const SKILL_SOURCES: RuleSource[] = getSkillsImportSources();
  constant TOOL_NAME_MAP (line 37) | const TOOL_NAME_MAP: Record<string, string> = getDirectoryPrefixMap();
  constant TOOL_DISPLAY_NAMES (line 42) | const TOOL_DISPLAY_NAMES: Record<string, string> = getDisplayNameMap();
  constant TOOL_CAPABILITIES (line 47) | const TOOL_CAPABILITIES: Record<string, ToolCapabilities> = getCapabilit...
  constant ALL_TOOL_IDS (line 52) | const ALL_TOOL_IDS = getAllToolIds();
  function getSkillSourceByName (line 61) | function getSkillSourceByName(name: string): RuleSource | undefined {
  function getAllSkillSourceNames (line 68) | function getAllSkillSourceNames(): string[] {
  function getToolIdFromPath (line 77) | function getToolIdFromPath(filePath: string): string {
  function getToolDisplayName (line 84) | function getToolDisplayName(toolId: string): string {
  function getToolCapabilities (line 91) | function getToolCapabilities(toolId: string): ToolCapabilities {

FILE: src/services/reverseSync/reverseQuickSyncService.ts
  class ReverseQuickSyncService (line 32) | class ReverseQuickSyncService {
    method constructor (line 42) | constructor(deps: ReverseSyncServiceDependencies) {
    method run (line 56) | async run(repoPath: string, options: ReverseSyncCommandFlags = {}): Pr...
    method detect (line 201) | async detect(repoPath: string): Promise<ToolDetectionResult> {
    method preview (line 208) | async preview(repoPath: string, options: ReverseSyncCommandFlags = {})...
    method resolveOptions (line 212) | private resolveOptions(
    method displaySummary (line 232) | private displaySummary(result: ReverseSyncResult, options: ReverseSync...
  function createReverseQuickSyncService (line 292) | function createReverseQuickSyncService(

FILE: src/services/reverseSync/skillsDetector.ts
  class SkillsDetector (line 14) | class SkillsDetector {
    method detectSkills (line 18) | async detectSkills(repoPath: string, autoDetect: boolean = true): Prom...
    method detectFromPaths (line 107) | async detectFromPaths(sourcePaths: string[], repoPath: string): Promis...
    method createSkillFileInfo (line 171) | private async createSkillFileInfo(
    method parseSkillMetadata (line 213) | private parseSkillMetadata(content: string): SkillMetadata | undefined {
    method parseArrayValue (line 263) | private parseArrayValue(value: string): string[] {
    method slugToName (line 274) | private slugToName(slug: string): string {

FILE: src/services/reverseSync/toolDetector.ts
  class ToolDetector (line 21) | class ToolDetector {
    method constructor (line 26) | constructor() {
    method detect (line 36) | async detect(repoPath: string): Promise<ToolDetectionResult> {
    method detectTool (line 67) | async detectTool(repoPath: string, toolId: string): Promise<ToolPresen...
    method groupByTool (line 75) | private groupByTool(
    method getToolIdForRule (line 157) | private getToolIdForRule(rule: RuleFileInfo): string {
  function formatDetectionSummary (line 188) | function formatDetectionSummary(result: ToolDetectionResult): string {

FILE: src/services/reverseSync/types.ts
  type MergeStrategy (line 16) | type MergeStrategy = 'skip' | 'overwrite' | 'merge' | 'rename';
  type ToolPresence (line 25) | interface ToolPresence {
  type ToolDetectionResult (line 50) | interface ToolDetectionResult {
  type SkillMetadata (line 70) | interface SkillMetadata {
  type SkillFileInfo (line 81) | interface SkillFileInfo {
  type SkillDetectionResult (line 101) | interface SkillDetectionResult {
  type ImportMetadata (line 113) | interface ImportMetadata {
  type ReverseSyncCommandFlags (line 135) | interface ReverseSyncCommandFlags {
  type ReverseSyncOptions (line 151) | interface ReverseSyncOptions {
  type ImportAction (line 169) | type ImportAction = 'created' | 'overwritten' | 'merged' | 'renamed' | '...
  type ImportContentType (line 174) | type ImportContentType = 'rule' | 'agent' | 'skill';
  type ImportedFileRecord (line 179) | interface ImportedFileRecord {
  type ReverseSyncResult (line 191) | interface ReverseSyncResult {
  type ImportSkillsOptions (line 206) | interface ImportSkillsOptions {
  type ImportSkillsCommandFlags (line 220) | interface ImportSkillsCommandFlags {
  type ReverseSyncServiceDependencies (line 235) | interface ReverseSyncServiceDependencies {

FILE: src/services/semantic/codebaseAnalyzer.test.ts
  function createTempOutput (line 78) | function createTempOutput(prefix: string): Promise<string> {

FILE: src/services/semantic/codebaseAnalyzer.ts
  constant DEFAULT_OPTIONS (line 32) | const DEFAULT_OPTIONS: Required<AnalyzerOptions> = {
  class CodebaseAnalyzer (line 41) | class CodebaseAnalyzer {
    method constructor (line 46) | constructor(options: AnalyzerOptions = {}) {
    method analyze (line 56) | async analyze(projectPath: string): Promise<SemanticContext> {
    method findCodeFiles (line 82) | private async findCodeFiles(projectPath: string): Promise<string[]> {
    method analyzeFiles (line 116) | private async analyzeFiles(files: string[]): Promise<Map<string, FileA...
    method buildBaseContext (line 134) | private buildBaseContext(
    method resolveImportPath (line 212) | private resolveImportPath(
    method fileExistsSync (line 243) | private fileExistsSync(filePath: string): boolean {
    method detectArchitecture (line 252) | private detectArchitecture(
    method detectLayers (line 267) | private detectLayers(
    method detectPatterns (line 358) | private detectPatterns(analyses: Map<string, FileAnalysis>): DetectedP...
    method findEntryPoints (line 458) | private findEntryPoints(
    method findPublicAPI (line 481) | private findPublicAPI(analyses: Map<string, FileAnalysis>): ExtractedS...
    method calculateLayerDependencies (line 502) | private calculateLayerDependencies(
    method getSummary (line 546) | getSummary(context: SemanticContext, projectPath: string): string {
    method clearCache (line 591) | clearCache(): void {
    method shutdown (line 598) | async shutdown(): Promise<void> {
    method enhanceWithLSP (line 608) | private async enhanceWithLSP(
    method detectFunctionalPatterns (line 673) | async detectFunctionalPatterns(projectPath: string): Promise<DetectedF...
    method detectAuthPattern (line 738) | private detectAuthPattern(
    method detectDatabasePattern (line 792) | private detectDatabasePattern(
    method detectApiPattern (line 848) | private detectApiPattern(
    method detectCachePattern (line 902) | private detectCachePattern(
    method detectQueuePattern (line 943) | private detectQueuePattern(
    method detectWebSocketPattern (line 984) | private detectWebSocketPattern(
    method detectLoggingPattern (line 1025) | private detectLoggingPattern(
    method detectValidationPattern (line 1066) | private detectValidationPattern(
    method detectErrorHandlingPattern (line 1107) | private detectErrorHandlingPattern(
    method detectTestingPattern (line 1148) | private detectTestingPattern(
    method traceFlow (line 1191) | async traceFlow(
    method traceCallsFromFile (line 1260) | private async traceCallsFromFile(
    method generateMermaidDiagram (line 1363) | private generateMermaidDiagram(nodes: FlowNode[], edges: FlowEdge[]): ...

FILE: src/services/semantic/contextBuilder.ts
  type ContextBuilderOptions (line 19) | interface ContextBuilderOptions extends AnalyzerOptions {
  type ContextFormat (line 30) | type ContextFormat = 'documentation' | 'playbook' | 'plan' | 'compact';
  constant DEFAULT_OPTIONS (line 32) | const DEFAULT_OPTIONS: Required<ContextBuilderOptions> = {
  class SemanticContextBuilder (line 45) | class SemanticContextBuilder {
    method constructor (line 51) | constructor(options: ContextBuilderOptions = {}) {
    method analyze (line 59) | async analyze(projectPath: string): Promise<SemanticContext> {
    method buildDocumentationContext (line 72) | async buildDocumentationContext(
    method buildPlaybookContext (line 105) | async buildPlaybookContext(
    method buildPlanContext (line 135) | async buildPlanContext(
    method buildCompactContext (line 169) | async buildCompactContext(projectPath: string): Promise<string> {
    method buildSkillContext (line 183) | async buildSkillContext(
    method getSemanticContext (line 227) | async getSemanticContext(projectPath: string): Promise<SemanticContext> {
    method formatArchitectureOverview (line 233) | private formatArchitectureOverview(context: SemanticContext): string {
    method formatPublicAPI (line 255) | private formatPublicAPI(context: SemanticContext, projectPath: string)...
    method formatSymbolIndex (line 276) | private formatSymbolIndex(context: SemanticContext, projectPath: strin...
    method formatSymbolLine (line 307) | private formatSymbolLine(symbol: ExtractedSymbol, projectPath: string)...
    method formatTargetFileContext (line 330) | private formatTargetFileContext(
    method formatDependencyOverview (line 362) | private formatDependencyOverview(context: SemanticContext, projectPath...
    method formatRelevantLayers (line 388) | private formatRelevantLayers(
    method formatRelevantPatterns (line 415) | private formatRelevantPatterns(patterns: DetectedPattern[]): string {
    method formatKeyFilesForAgent (line 434) | private formatKeyFilesForAgent(
    method formatRelevantSymbolsForAgent (line 465) | private formatRelevantSymbolsForAgent(
    method formatFullArchitecture (line 493) | private formatFullArchitecture(
    method formatAllPatterns (line 525) | private formatAllPatterns(context: SemanticContext): string {
    method formatEntryPoints (line 541) | private formatEntryPoints(context: SemanticContext): string {
    method formatLayerDependencies (line 554) | private formatLayerDependencies(context: SemanticContext): string {
    method formatSymbolsByLayer (line 571) | private formatSymbolsByLayer(
    method formatCompactSymbolList (line 601) | private formatCompactSymbolList(
    method getRelevantLayersForAgent (line 624) | private getRelevantLayersForAgent(
    method getRelevantPatternsForAgent (line 651) | private getRelevantPatternsForAgent(
    method getKeyPatternsForAgent (line 671) | private getKeyPatternsForAgent(agentType: string): RegExp[] {
    method getRelevantPatternsForSkill (line 692) | private getRelevantPatternsForSkill(
    method getKeyPatternsForSkill (line 717) | private getKeyPatternsForSkill(skillType: string): RegExp[] {
    method formatKeyFilesForSkill (line 734) | private formatKeyFilesForSkill(
    method formatRelevantSymbolsForSkill (line 765) | private formatRelevantSymbolsForSkill(
    method truncateToLimit (line 793) | private truncateToLimit(content: string): string {
    method clearCache (line 807) | clearCache(): void {
    method shutdown (line 816) | async shutdown(): Promise<void> {

FILE: src/services/semantic/contextCache.ts
  type CacheEntry (line 20) | interface CacheEntry {
  type ContextCacheOptions (line 29) | interface ContextCacheOptions {
  constant DEFAULT_TTL_MS (line 36) | const DEFAULT_TTL_MS = 5 * 60 * 1000;
  constant DEFAULT_WATCH_DIRS (line 37) | const DEFAULT_WATCH_DIRS = ['src', '.context', 'lib', 'packages'];
  class ContextCache (line 39) | class ContextCache {
    method constructor (line 44) | constructor(options: ContextCacheOptions = {}) {
    method get (line 56) | async get(repoPath: string, contextType: string): Promise<string | nul...
    method set (line 87) | async set(repoPath: string, contextType: string, content: string): Pro...
    method invalidateRepo (line 101) | invalidateRepo(repoPath: string): void {
    method clear (line 113) | clear(): void {
    method size (line 120) | get size(): number {
    method buildKey (line 127) | private buildKey(repoPath: string, contextType: string): string {
    method normalizeRepoPath (line 134) | private normalizeRepoPath(repoPath: string): string {
    method computeMtimeHash (line 143) | private async computeMtimeHash(repoPath: string): Promise<string> {

FILE: src/services/semantic/lsp/lspLayer.ts
  type LSPMessage (line 18) | interface LSPMessage {
  type PendingRequest (line 27) | interface PendingRequest {
  constant LSP_SERVER_CONFIGS (line 33) | const LSP_SERVER_CONFIGS: Record<string, LSPServerConfig> = {
  constant REQUEST_TIMEOUT_MS (line 51) | const REQUEST_TIMEOUT_MS = 10000;
  class LSPLayer (line 53) | class LSPLayer {
    method detectLanguage (line 60) | private detectLanguage(filePath: string): SupportedLanguage | null {
    method getServerConfig (line 65) | private getServerConfig(language: string): LSPServerConfig | null {
    method ensureServer (line 69) | async ensureServer(language: string, projectPath: string): Promise<boo...
    method handleServerData (line 151) | private handleServerData(language: string, data: Buffer): void {
    method handleMessage (line 177) | private handleMessage(message: LSPMessage): void {
    method sendRequest (line 191) | private sendRequest(language: string, method: string, params: unknown)...
    method sendNotification (line 213) | private sendNotification(language: string, method: string, params: unk...
    method sendMessage (line 222) | private sendMessage(language: string, message: LSPMessage): void {
    method cleanup (line 236) | private cleanup(language: string): void {
    method getTypeInfo (line 249) | async getTypeInfo(
    method findReferences (line 277) | async findReferences(
    method getDefinition (line 310) | async getDefinition(
    method findImplementations (line 343) | async findImplementations(
    method parseHoverResult (line 375) | private parseHoverResult(contents: unknown): TypeInfo {
    method shutdown (line 399) | async shutdown(): Promise<void> {
    method isServerAvailable (line 419) | isServerAvailable(language: string): boolean {
    method getAvailableLanguages (line 423) | getAvailableLanguages(): string[] {

FILE: src/services/semantic/semanticSnapshotService.ts
  type SemanticSnapshotSection (line 18) | type SemanticSnapshotSection =
  type SnapshotFileSection (line 30) | type SnapshotFileSection = Exclude<SemanticSnapshotSection, 'all' | 'met...
  type SemanticSnapshotManifest (line 32) | interface SemanticSnapshotManifest extends SemanticSnapshotMetadata {
  type SemanticSnapshotWriteOptions (line 37) | interface SemanticSnapshotWriteOptions {
  type SemanticSnapshotWriteResult (line 46) | interface SemanticSnapshotWriteResult {
  type SemanticSnapshotReadOptions (line 53) | interface SemanticSnapshotReadOptions {
  type SemanticSnapshotSectionResult (line 58) | interface SemanticSnapshotSectionResult {
  type SemanticSnapshotRefreshReason (line 66) | type SemanticSnapshotRefreshReason = 'fresh' | 'stale' | 'missing';
  type SemanticSnapshotEnsureSummaryResult (line 68) | interface SemanticSnapshotEnsureSummaryResult {
  type SemanticSnapshotEnsureSectionResult (line 78) | interface SemanticSnapshotEnsureSectionResult extends SemanticSnapshotSe...
  type SnapshotArtifacts (line 84) | interface SnapshotArtifacts {
  constant SNAPSHOT_SCHEMA_VERSION (line 89) | const SNAPSHOT_SCHEMA_VERSION = '2.0.0';
  constant SNAPSHOT_DIRNAME (line 90) | const SNAPSHOT_DIRNAME = path.join('cache', 'semantic');
  constant MANIFEST_FILENAME (line 91) | const MANIFEST_FILENAME = 'manifest.json';
  constant SUMMARY_FILENAME (line 92) | const SUMMARY_FILENAME = 'summary.json';
  constant VERSIONS_DIRNAME (line 93) | const VERSIONS_DIRNAME = 'versions';
  constant MAX_REFRESH_ATTEMPTS (line 94) | const MAX_REFRESH_ATTEMPTS = 3;
  constant MAX_VERSION_HISTORY (line 95) | const MAX_VERSION_HISTORY = 3;
  constant SECTION_FILENAMES (line 97) | const SECTION_FILENAMES: Record<SnapshotFileSection, string> = {
  constant LEGACY_CODEBASE_MAP_PATH (line 108) | const LEGACY_CODEBASE_MAP_PATH = path.join('docs', 'codebase-map.json');
  constant FINGERPRINT_IGNORE_PATTERNS (line 110) | const FINGERPRINT_IGNORE_PATTERNS = [
  constant FINGERPRINT_ROOT_FILES (line 121) | const FINGERPRINT_ROOT_FILES = new Set([
  constant FINGERPRINT_CODE_EXTENSIONS (line 146) | const FINGERPRINT_CODE_EXTENSIONS = new Set([
  class SemanticSnapshotService (line 161) | class SemanticSnapshotService {
    method captureRepoFingerprint (line 164) | async captureRepoFingerprint(repoPath: string): Promise<string> {
    method writeSnapshot (line 168) | async writeSnapshot(
    method ensureFreshSummary (line 198) | async ensureFreshSummary(
    method ensureFreshSection (line 227) | async ensureFreshSection(
    method readSummary (line 252) | async readSummary(
    method readSection (line 274) | async readSection(
    method refreshSnapshot (line 291) | private async refreshSnapshot(
    method inspectSummary (line 354) | private async inspectSummary(
    method inspectSection (line 393) | private async inspectSection(
    method buildSnapshotArtifacts (line 415) | private async buildSnapshotArtifacts(
    method publishSnapshotArtifacts (line 486) | private async publishSnapshotArtifacts(params: {
    method buildSectionResult (line 539) | private buildSectionResult(
    method buildSectionResultFromManifest (line 566) | private async buildSectionResultFromManifest(
    method extractSectionData (line 600) | private extractSectionData(map: CodebaseMap, section: SemanticSnapshot...
    method getSectionData (line 625) | private getSectionData(summary: CodebaseMap): Record<SnapshotFileSecti...
    method replaceFile (line 638) | private async replaceFile(targetPath: string, sourcePath: string): Pro...
    method promoteFile (line 660) | private async promoteFile(sourcePath: string, targetPath: string): Pro...
    method getSnapshotDir (line 668) | private getSnapshotDir(outputDir: string): string {
    method buildPublishedManifest (line 672) | private buildPublishedManifest(
    method createVersionId (line 693) | private createVersionId(): string {
    method pruneSnapshotVersions (line 697) | private async pruneSnapshotVersions(snapshotDir: string): Promise<void> {
    method resolveOutputDir (line 722) | private resolveOutputDir(repoPath: string, outputDir?: string): string {
    method isFresh (line 728) | private async isFresh(repoPath: string, expectedFingerprint: string): ...
    method computeRepoFingerprint (line 732) | private async computeRepoFingerprint(repoPath: string): Promise<string> {
    method isFingerprintRelevant (line 759) | private isFingerprintRelevant(relativePath: string): boolean {

FILE: src/services/semantic/treeSitter/treeSitterLayer.ts
  type CacheEntry (line 19) | interface CacheEntry {
  class TreeSitterLayer (line 24) | class TreeSitterLayer {
    method constructor (line 30) | constructor() {
    method initializeParsers (line 34) | private async initializeParsers(): Promise<void> {
    method analyzeFile (line 57) | async analyzeFile(filePath: string): Promise<FileAnalysis> {
    method analyzeWithTreeSitter (line 94) | private analyzeWithTreeSitter(
    method extractFromTreeSitter (line 114) | private extractFromTreeSitter(
    method extractClassFromTree (line 163) | private extractClassFromTree(node: any, filePath: string): ExtractedSy...
    method extractInterfaceFromTree (line 178) | private extractInterfaceFromTree(node: any, filePath: string): Extract...
    method extractFunctionFromTree (line 193) | private extractFunctionFromTree(node: any, filePath: string): Extracte...
    method extractTypeFromTree (line 208) | private extractTypeFromTree(node: any, filePath: string): ExtractedSym...
    method extractEnumFromTree (line 223) | private extractEnumFromTree(node: any, filePath: string): ExtractedSym...
    method extractImportFromTree (line 238) | private extractImportFromTree(node: any): ImportInfo {
    method extractExportFromTree (line 271) | private extractExportFromTree(node: any): ExportInfo | null {
    method isNodeExported (line 291) | private isNodeExported(node: any): boolean {
    method extractDocComment (line 300) | private extractDocComment(node: any): string | undefined {
    method analyzeWithRegex (line 315) | private analyzeWithRegex(
    method analyzeTypeScriptWithRegex (line 331) | private analyzeTypeScriptWithRegex(
    method analyzePythonWithRegex (line 487) | private analyzePythonWithRegex(filePath: string, content: string): Fil...
    method emptyAnalysis (line 550) | private emptyAnalysis(filePath: string, language: string): FileAnalysis {
    method clearCache (line 560) | clearCache(): void {
    method isTreeSitterAvailable (line 564) | async isTreeSitterAvailable(): Promise<boolean> {

FILE: src/services/semantic/types.ts
  type SymbolKind (line 5) | type SymbolKind = 'class' | 'interface' | 'function' | 'type' | 'variabl...
  type SymbolLocation (line 7) | interface SymbolLocation {
  type ParameterInfo (line 13) | interface ParameterInfo {
  type ExtractedSymbol (line 20) | interface ExtractedSymbol {
  type ImportInfo (line 37) | interface ImportInfo {
  type ExportInfo (line 45) | interface ExportInfo {
  type FileAnalysis (line 52) | interface FileAnalysis {
  type ArchitectureLayer (line 60) | interface ArchitectureLayer {
  type DetectedPattern (line 68) | interface DetectedPattern {
  type FunctionalPatternType (line 79) | type FunctionalPatternType =
  type FunctionalPattern (line 91) | interface FunctionalPattern {
  type PatternIndicator (line 98) | interface PatternIndicator {
  type DetectedFunctionalPatterns (line 105) | interface DetectedFunctionalPatterns {
  type FlowNode (line 122) | interface FlowNode {
  type FlowEdge (line 129) | interface FlowEdge {
  type ExecutionFlow (line 135) | interface ExecutionFlow {
  type DependencyInfo (line 142) | interface DependencyInfo {
  type ArchitectureInfo (line 147) | interface ArchitectureInfo {
  type SemanticStats (line 154) | interface SemanticStats {
  type SemanticContext (line 161) | interface SemanticContext {
  type TypeInfo (line 174) | interface TypeInfo {
  type ReferenceLocation (line 180) | interface ReferenceLocation {
  type AnalyzerOptions (line 187) | interface AnalyzerOptions {
  type LSPServerConfig (line 196) | interface LSPServerConfig {
  type SupportedLanguage (line 202) | type SupportedLanguage =
  constant LANGUAGE_EXTENSIONS (line 207) | const LANGUAGE_EXTENSIONS: Record<string, SupportedLanguage> = {
  constant DEFAULT_EXCLUDE_PATTERNS (line 219) | const DEFAULT_EXCLUDE_PATTERNS = [

FILE: src/services/shared/contentTypeRegistry.ts
  type ContentType (line 12) | interface ContentType {
  constant CONTENT_TYPE_REGISTRY (line 34) | const CONTENT_TYPE_REGISTRY: ContentType[] = [
  function getContentType (line 86) | function getContentType(id: string): ContentType | undefined {
  function getExportableContentTypes (line 93) | function getExportableContentTypes(): ContentType[] {
  function getImportableContentTypes (line 100) | function getImportableContentTypes(): ContentType[] {
  function getContentTypeIds (line 107) | function getContentTypeIds(): string[] {
  function hasContentType (line 114) | function hasContentType(id: string): boolean {
  function registerContentType (line 122) | function registerContentType(contentType: ContentType): void {
  function getContextPath (line 132) | function getContextPath(id: string): string | undefined {
  function getIndexFile (line 139) | function getIndexFile(id: string): string | undefined {

FILE: src/services/shared/contextLayout.ts
  type ContextLayoutClassification (line 8) | type ContextLayoutClassification = 'versioned' | 'local' | 'runtime';
  type ContextLayoutEntry (line 10) | interface ContextLayoutEntry {
  constant CONTEXT_LAYOUT_REGISTRY (line 18) | const CONTEXT_LAYOUT_REGISTRY: ContextLayoutEntry[] = [
  function getContextLayoutByClassification (line 140) | function getContextLayoutByClassification(
  function getUntrackedContextLayoutEntries (line 146) | function getUntrackedContextLayoutEntries(): ContextLayoutEntry[] {

FILE: src/services/shared/contextRootResolver.ts
  function resolveContextPath (line 17) | function resolveContextPath(repoPath?: string): string {
  type SimpleContextResult (line 28) | interface SimpleContextResult {
  function resolveSimpleContext (line 42) | async function resolveSimpleContext(repoPath?: string): Promise<SimpleCo...
  function getContextPath (line 58) | async function getContextPath(repoPath: string = process.cwd()): Promise...
  function getProjectRoot (line 67) | async function getProjectRoot(repoPath: string = process.cwd()): Promise...
  type ContextResolutionResult (line 75) | interface ContextResolutionResult {
  function resolveContextRoot (line 82) | async function resolveContextRoot(options?: { startPath?: string; valida...

FILE: src/services/shared/globPatterns.ts
  constant COMMON_IGNORES (line 13) | const COMMON_IGNORES = [
  constant CODE_EXTENSIONS (line 31) | const CODE_EXTENSIONS = [
  constant DOC_EXTENSIONS (line 49) | const DOC_EXTENSIONS = ['md', 'mdx', 'txt', 'rst'] as const;
  constant CONFIG_PATTERNS (line 54) | const CONFIG_PATTERNS = [
  type GlobFilesOptions (line 69) | interface GlobFilesOptions {
  function globFiles (line 79) | async function globFiles(
  function globMultiple (line 108) | async function globMultiple(
  function buildExtensionPattern (line 124) | function buildExtensionPattern(extensions: readonly string[]): string {
  function shouldIgnore (line 134) | function shouldIgnore(filePath: string): boolean {

FILE: src/services/shared/pathHelpers.ts
  type ContextPaths (line 18) | interface ContextPaths {
  type ContextPathsWithResolution (line 31) | interface ContextPathsWithResolution extends ContextPaths {
  function resolveContextPaths (line 40) | function resolveContextPaths(repoPath: string): ContextPaths {
  function resolveContextPathsAsync (line 59) | async function resolveContextPathsAsync(
  function resolveAbsolutePath (line 84) | function resolveAbsolutePath(
  function ensureDirectory (line 98) | async function ensureDirectory(dirPath: string): Promise<void> {
  function ensureParentDirectory (line 105) | async function ensureParentDirectory(filePath: string): Promise<void> {
  function getRelativePath (line 112) | function getRelativePath(fullPath: string, basePath: string): string {
  function pathExists (line 119) | async function pathExists(targetPath: string): Promise<boolean> {
  function isDirectory (line 126) | async function isDirectory(targetPath: string): Promise<boolean> {
  function isFile (line 138) | async function isFile(targetPath: string): Promise<boolean> {
  function normalizePath (line 150) | function normalizePath(inputPath: string): string {
  function deduplicatePaths (line 157) | function deduplicatePaths(paths: string[]): string[] {
  function getExtension (line 164) | function getExtension(filePath: string): string {
  function getBasename (line 172) | function getBasename(filePath: string): string {
  function joinPaths (line 179) | function joinPaths(...parts: (string | undefined)[]): string {

FILE: src/services/shared/toolRegistry.ts
  type ToolCapabilities (line 15) | interface ToolCapabilities {
  type ToolPaths (line 21) | interface ToolPaths {
  type ToolDefinition (line 46) | interface ToolDefinition {
  constant TOOL_REGISTRY (line 67) | const TOOL_REGISTRY: ToolDefinition[] = [
  function getToolById (line 405) | function getToolById(id: string): ToolDefinition | undefined {
  function getAllToolIds (line 412) | function getAllToolIds(): string[] {
  function getToolsWithCapability (line 419) | function getToolsWithCapability(capability: keyof ToolCapabilities): Too...
  function getToolIdFromPath (line 426) | function getToolIdFromPath(filePath: string): string {
  function getToolDisplayName (line 458) | function getToolDisplayName(toolId: string): string {
  function getToolCapabilities (line 466) | function getToolCapabilities(toolId: string): ToolCapabilities {
  function getDirectoryPrefixMap (line 474) | function getDirectoryPrefixMap(): Record<string, string> {
  function getDisplayNameMap (line 485) | function getDisplayNameMap(): Record<string, string> {
  function getCapabilitiesMap (line 496) | function getCapabilitiesMap(): Record<string, ToolCapabilities> {
  function getRulesExportPresets (line 511) | function getRulesExportPresets(): Record<string, Array<{
  function getAgentsSyncPresets (line 538) | function getAgentsSyncPresets(): Record<string, {
  function getSkillsExportPresets (line 563) | function getSkillsExportPresets(): Record<string, Array<{
  function getRulesImportSources (line 586) | function getRulesImportSources(): Array<{
  function getAgentsImportSources (line 608) | function getAgentsImportSources(): Array<{
  function getSkillsImportSources (line 627) | function getSkillsImportSources(): Array<{

FILE: src/services/shared/types.ts
  type BaseDependencies (line 14) | interface BaseDependencies {
  type OperationResult (line 23) | interface OperationResult {
  type OperationError (line 33) | interface OperationError {
  type FileInfo (line 41) | interface FileInfo {
  type DetectionResult (line 50) | interface DetectionResult<T extends FileInfo = FileInfo> {
  type DryRunOptions (line 58) | interface DryRunOptions {
  function createEmptyResult (line 67) | function createEmptyResult(): OperationResult {
  function mergeResults (line 79) | function mergeResults(...results: OperationResult[]): OperationResult {
  function addError (line 94) | function addError(

FILE: src/services/shared/uiHelpers.ts
  type SpinnerStatus (line 16) | type SpinnerStatus = 'success' | 'fail' | 'warn' | 'info';
  function withSpinner (line 21) | async function withSpinner<T>(
  function displayOperationSummary (line 67) | function displayOperationSummary(
  function displayProgressBar (line 111) | function displayProgressBar(
  function displayPhaseIndicator (line 144) | function displayPhaseIndicator(
  function createBox (line 189) | function createBox(

FILE: src/services/stack/projectTypeClassifier.ts
  constant PROJECT_TYPES (line 10) | const PROJECT_TYPES = [
  type ProjectType (line 22) | type ProjectType = (typeof PROJECT_TYPES)[number];
  type ProjectClassification (line 24) | interface ProjectClassification {
  constant FRAMEWORK_CATEGORIES (line 35) | const FRAMEWORK_CATEGORIES = {
  constant CONFIDENCE_THRESHOLDS (line 86) | const CONFIDENCE_THRESHOLDS = {
  type ExtendedStackInfo (line 94) | interface ExtendedStackInfo extends StackInfo {
  function matchesCategory (line 104) | function matchesCategory(frameworks: string[], category: readonly string...
  function getMatchingFrameworks (line 113) | function getMatchingFrameworks(frameworks: string[], category: readonly ...
  function classifyProject (line 122) | function classifyProject(stack: StackInfo | ExtendedStackInfo): ProjectC...
  constant TYPE_PRIORITY (line 225) | const TYPE_PRIORITY: readonly ProjectType[] = [
  function prioritizeTypes (line 239) | function prioritizeTypes(detectedTypes: ProjectType[]): {
  function calculateConfidence (line 262) | function calculateConfidence(reasoningCount: number): 'high' | 'medium' ...
  function detectCLILibraries (line 275) | function detectCLILibraries(dependencies: Record<string, string>): strin...
  function isLibraryPackage (line 282) | function isLibraryPackage(packageJson: {

FILE: src/services/stack/scaffoldFilter.ts
  constant CORE_AGENTS (line 19) | const CORE_AGENTS: readonly AgentType[] = [
  constant CORE_DOCS (line 32) | const CORE_DOCS: readonly string[] = [
  constant CORE_SKILLS (line 42) | const CORE_SKILLS: readonly BuiltInSkillType[] = [
  constant EXTRA_AGENTS_BY_TYPE (line 55) | const EXTRA_AGENTS_BY_TYPE: Record<ProjectType, readonly AgentType[]> = {
  constant EXTRA_DOCS_BY_TYPE (line 70) | const EXTRA_DOCS_BY_TYPE: Record<ProjectType, readonly string[]> = {
  constant EXTRA_SKILLS_BY_TYPE (line 85) | const EXTRA_SKILLS_BY_TYPE: Record<ProjectType, readonly BuiltInSkillTyp...
  function buildAgentMatrix (line 98) | function buildAgentMatrix(): Record<ProjectType, Record<AgentType, boole...
  function buildDocsMatrix (line 113) | function buildDocsMatrix(): Record<ProjectType, Record<string, boolean>> {
  function buildSkillsMatrix (line 128) | function buildSkillsMatrix(): Record<ProjectType, Record<BuiltInSkillTyp...
  constant AGENT_FILTER_MATRIX (line 147) | const AGENT_FILTER_MATRIX = buildAgentMatrix();
  constant DOCS_FILTER_MATRIX (line 153) | const DOCS_FILTER_MATRIX = buildDocsMatrix();
  constant SKILLS_FILTER_MATRIX (line 159) | const SKILLS_FILTER_MATRIX = buildSkillsMatrix();
  function getAgentsForProjectType (line 165) | function getAgentsForProjectType(projectType: ProjectType): AgentType[] {
  function getDocsForProjectType (line 174) | function getDocsForProjectType(projectType: ProjectType): string[] {
  function getSkillsForProjectType (line 183) | function getSkillsForProjectType(projectType: ProjectType): BuiltInSkill...
  function getFilteredScaffolds (line 191) | function getFilteredScaffolds(projectType: ProjectType): {
  function shouldIncludeAgent (line 206) | function shouldIncludeAgent(projectType: ProjectType, agent: AgentType):...
  function shouldIncludeDoc (line 214) | function shouldIncludeDoc(projectType: ProjectType, doc: string): boolean {
  function shouldIncludeSkill (line 222) | function shouldIncludeSkill(projectType: ProjectType, skill: BuiltInSkil...
  function validateConfiguration (line 231) | function validateConfiguration(): void {

FILE: src/services/stack/stackDetector.ts
  type StackInfo (line 11) | interface StackInfo {
  type DetectionRule (line 29) | interface DetectionRule {
  constant DETECTION_RULES (line 38) | const DETECTION_RULES: DetectionRule[] = [
  constant LANGUAGE_EXTENSIONS (line 157) | const LANGUAGE_EXTENSIONS: Record<string, string> = {
  class StackDetector (line 180) | class StackDetector {
    method detect (line 184) | async detect(repoPath: string): Promise<StackInfo> {
    method getRecommendedAgents (line 273) | getRecommendedAgents(stack: StackInfo): string[] {
    method getRecommendedRules (line 309) | getRecommendedRules(stack: StackInfo): string[] {
    method checkFileExists (line 331) | private async checkFileExists(basePath: string, pattern: string): Prom...
    method countLanguagesByExtension (line 351) | private async countLanguagesByExtension(basePath: string): Promise<Rec...
    method hasCI (line 375) | private async hasCI(basePath: string): Promise<boolean> {
    method analyzePackageJson (line 399) | private async analyzePackageJson(basePath: string): Promise<{

FILE: src/services/sync/markdownReferenceHandler.ts
  function getTargetFilename (line 5) | function getTargetFilename(agent: AgentFileInfo, options: HandlerOptions...
  function createMarkdownReferences (line 10) | async function createMarkdownReferences(
  function generateReferenceMarkdown (line 61) | function generateReferenceMarkdown(
  function formatAgentTitle (line 117) | function formatAgentTitle(name: string): string {

FILE: src/services/sync/presets.ts
  function buildTargetPresets (line 8) | function buildTargetPresets(): Record<Exclude<PresetName, 'all'>, Target...
  constant TARGET_PRESETS (line 27) | const TARGET_PRESETS: Record<Exclude<PresetName, 'all'>, TargetPreset> =...
  function resolvePresets (line 29) | function resolvePresets(presetName: PresetName): TargetPreset[] {
  function getPresetByPath (line 38) | function getPresetByPath(targetPath: string): TargetPreset | undefined {
  function getAllPresetNames (line 53) | function getAllPresetNames(): PresetName[] {

FILE: src/services/sync/symlinkHandler.ts
  function getTargetFilename (line 5) | function getTargetFilename(agent: AgentFileInfo, options: HandlerOptions...
  function createSymlinks (line 10) | async function createSymlinks(
  function createPlatformSymlink (line 66) | async function createPlatformSymlink(
  function checkSymlinkSupport (line 89) | async function checkSymlinkSupport(): Promise<{

FILE: src/services/sync/syncService.ts
  class SyncService (line 20) | class SyncService {
    method constructor (line 25) | constructor(dependencies: SyncServiceDependencies) {
    method run (line 31) | async run(rawOptions: SyncCommandFlags): Promise<SyncRunResult> {
    method resolveOptions (line 95) | private async resolveOptions(rawOptions: SyncCommandFlags): Promise<Sy...
    method validateSource (line 136) | private async validateSource(sourcePath: string): Promise<void> {
    method discoverAgentFiles (line 148) | private async discoverAgentFiles(sourcePath: string): Promise<AgentFil...
    method syncToTarget (line 173) | private async syncToTarget(
    method displayConfig (line 235) | private displayConfig(options: SyncOptions): void {
    method displaySummary (line 252) | private displaySummary(results: SyncResult[], dryRun: boolean): void {

FILE: src/services/sync/types.ts
  type SyncMode (line 4) | type SyncMode = 'symlink' | 'markdown';
  type PresetName (line 6) | type PresetName = string;
  type TargetPreset (line 8) | interface TargetPreset {
  type SyncCommandFlags (line 15) | interface SyncCommandFlags {
  type SyncServiceDependencies (line 25) | interface SyncServiceDependencies {
  type SyncOptions (line 31) | interface SyncOptions {
  type SyncResult (line 40) | interface SyncResult {
  type AgentFileInfo (line 48) | interface AgentFileInfo {
  type HandlerOptions (line 55) | interface HandlerOptions {
  type HandlerResult (line 62) | interface HandlerResult {
  type SyncRunResult (line 69) | interface SyncRunResult {

FILE: src/services/workflow/autoAdvance.ts
  type AutoAdvanceResult (line 16) | interface AutoAdvanceResult {
  constant PHASE_OUTPUT_PATTERNS (line 26) | const PHASE_OUTPUT_PATTERNS: Record<PrevcPhase, string[]> = {
  constant PHASE_MIN_FILES (line 70) | const PHASE_MIN_FILES: Record<PrevcPhase, number> = {
  class AutoAdvanceDetector (line 78) | class AutoAdvanceDetector {
    method constructor (line 82) | constructor(repoPath: string) {
    method checkAutoAdvance (line 90) | async checkAutoAdvance(
    method getExpectedOutputTypes (line 152) | private getExpectedOutputTypes(phase: PrevcPhase): string[] {
    method watchForOutputs (line 167) | async watchForOutputs(
    method validatePhaseOutputs (line 208) | async validatePhaseOutputs(

FILE: src/services/workflow/workflowService.ts
  type WorkflowHarnessStatus (line 49) | interface WorkflowHarnessStatus {
  class HarnessWorkflowBlockedError (line 69) | class HarnessWorkflowBlockedError extends Error {
    method constructor (line 70) | constructor(
  type WorkflowServiceDependencies (line 84) | interface WorkflowServiceDependencies {
  type WorkflowInitOptions (line 96) | interface WorkflowInitOptions {
  class WorkflowService (line 114) | class WorkflowService {
    method constructor (line 127) | constructor(
    method create (line 159) | static async create(
    method hasWorkflow (line 169) | async hasWorkflow(): Promise<boolean> {
    method init (line 176) | async init(options: WorkflowInitOptions): Promise<PrevcStatus> {
    method getStatus (line 240) | async getStatus(): Promise<PrevcStatus> {
    method getSummary (line 247) | async getSummary(): Promise<WorkflowSummary> {
    method getFormattedStatus (line 254) | async getFormattedStatus(): Promise<string> {
    method advance (line 313) | async advance(outputs?: string[], options?: { force?: boolean }): Prom...
    method checkGates (line 364) | async checkGates(): Promise<GateCheckResult> {
    method setSettings (line 371) | async setSettings(settings: Partial<WorkflowSettings>): Promise<Workfl...
    method getSettings (line 387) | async getSettings(): Promise<WorkflowSettings> {
    method listAvailableSensors (line 391) | listAvailableSensors(): Array<Pick<HarnessSensorDefinition, 'id' | 'na...
    method setAutonomousMode (line 402) | async setAutonomousMode(enabled: boolean): Promise<WorkflowSettings> {
    method markPlanCreated (line 415) | async markPlanCreated(planSlug: string): Promise<void> {
    method approvePlan (line 428) | async approvePlan(approver: PrevcRole | string, notes?: string): Promi...
    method getApproval (line 442) | async getApproval(): Promise<PlanApproval | undefined> {
    method handoff (line 449) | async handoff(
    method getPhaseOrchestration (line 501) | async getPhaseOrchestration(phase: PrevcPhase): Promise<PhaseOrchestra...
    method getNextAgentSuggestion (line 508) | getNextAgentSuggestion(currentAgent: string): { agent: string; reason:...
    method startCollaboration (line 515) | async startCollaboration(
    method contributeToCollaboration (line 535) | contributeToCollaboration(
    method endCollaboration (line 551) | async endCollaboration(sessionId: string): Promise<CollaborationSynthe...
    method getRecommendedActions (line 558) | async getRecommendedActions(): Promise<string[]> {
    method isComplete (line 565) | async isComplete(): Promise<boolean> {
    method updateTask (line 572) | async updateTask(task: string): Promise<void> {
    method startRole (line 585) | async startRole(role: PrevcRole): Promise<void> {
    method completeRole (line 601) | async completeRole(role: PrevcRole, outputs: string[]): Promise<void> {
    method getHarnessStatus (line 618) | async getHarnessStatus(): Promise<WorkflowHarnessStatus | null> {
    method checkpointHarnessSession (line 674) | async checkpointHarnessSession(
    method recordHarnessArtifact (line 702) | async recordHarnessArtifact(input: {
    method defineHarnessTask (line 723) | async defineHarnessTask(input: {
    method runHarnessSensors (line 756) | async runHarnessSensors(sensorIds: string[], metadata?: Record<string,...
    method ensureHarnessSession (line 780) | private async ensureHarnessSession(
    method requireHarnessBinding (line 813) | private async requireHarnessBinding(): Promise<WorkflowHarnessBinding> {
    method loadHarnessBinding (line 818) | private async loadHarnessBinding(): Promise<WorkflowHarnessBinding | n...
    method saveHarnessBinding (line 822) | private async saveHarnessBinding(binding: WorkflowHarnessBinding): Pro...
    method registerDefaultSensors (line 826) | private registerDefaultSensors(): void {
    method hasPackageScript (line 857) | private async hasPackageScript(scriptName: string): Promise<boolean> {
    method executeShellSensor (line 867) | private async executeShellSensor(command: string, name: string) {
    method trimEvidence (line 898) | private trimEvidence(value?: string, maxLength: number = 2000): string...

FILE: src/types.ts
  type FileInfo (line 1) | interface FileInfo {
  type TopLevelDirectoryStats (line 10) | interface TopLevelDirectoryStats {
  type RepoStructure (line 16) | interface RepoStructure {
  type AIProvider (line 25) | type AIProvider = 'openrouter' | 'openai' | 'anthropic' | 'google';
  type LLMConfig (line 27) | interface LLMConfig {
  type CLIOptions (line 34) | interface CLIOptions {
  type AgentPrompt (line 48) | interface AgentPrompt {
  type TokenUsage (line 56) | interface TokenUsage {
  type UsageStats (line 62) | interface UsageStats {

FILE: src/types/scaffoldFrontmatter.ts
  type ScaffoldFileType (line 14) | type ScaffoldFileType = 'doc' | 'agent' | 'skill' | 'plan';
  type ScaffoldStatus (line 19) | type ScaffoldStatus = 'unfilled' | 'filled';
  type BaseScaffoldFrontmatter (line 24) | interface BaseScaffoldFrontmatter {
  type DocScaffoldFrontmatter (line 42) | interface DocScaffoldFrontmatter extends BaseScaffoldFrontmatter {
  type AgentScaffoldFrontmatter (line 51) | interface AgentScaffoldFrontmatter extends BaseScaffoldFrontmatter {
  type SkillScaffoldFrontmatter (line 62) | interface SkillScaffoldFrontmatter extends BaseScaffoldFrontmatter {
  type PlanScaffoldFrontmatter (line 77) | interface PlanScaffoldFrontmatter extends BaseScaffoldFrontmatter {
  type ScaffoldFrontmatter (line 94) | type ScaffoldFrontmatter =
  function isDocFrontmatter (line 103) | function isDocFrontmatter(fm: ScaffoldFrontmatter): fm is DocScaffoldFro...
  function isAgentFrontmatter (line 110) | function isAgentFrontmatter(fm: ScaffoldFrontmatter): fm is AgentScaffol...
  function isSkillFrontmatter (line 117) | function isSkillFrontmatter(fm: ScaffoldFrontmatter): fm is SkillScaffol...
  function isPlanFrontmatter (line 124) | function isPlanFrontmatter(fm: ScaffoldFrontmatter): fm is PlanScaffoldF...
  function createDocFrontmatter (line 131) | function createDocFrontmatter(
  function createAgentFrontmatter (line 150) | function createAgentFrontmatter(
  function createSkillFrontmatter (line 171) | function createSkillFrontmatter(
  function createPlanFrontmatter (line 198) | function createPlanFrontmatter(
  function serializeFrontmatter (line 227) | function serializeFrontmatter(fm: ScaffoldFrontmatter): string {

FILE: src/utils/cliUI.ts
  class CLIInterface (line 7) | class CLIInterface {
    method constructor (line 12) | constructor(private readonly translate: TranslateFn) {}
    method displayProjectInfo (line 14) | displayProjectInfo(repoPath: string, outputDir: string, mode: string):...
    method startSpinner (line 23) | startSpinner(text: string): void {
    method updateSpinner (line 35) | updateSpinner(text: string, type?: 'success' | 'fail' | 'warn' | 'info...
    method stopSpinner (line 68) | stopSpinner(success: boolean = true): void {
    method createProgressBar (line 79) | createProgressBar(total: number, title: string): void {
    method updateProgress (line 94) | updateProgress(current: number, task: string): void {
    method completeProgress (line 99) | completeProgress(): void {
    method displayAnalysisResults (line 105) | displayAnalysisResults(totalFiles: number, totalDirs: number, totalSiz...
    method displayFileTypeDistribution (line 115) | displayFileTypeDistribution(distribution: Map<string, number>, totalFi...
    method displayGenerationSummary (line 135) | displayGenerationSummary(docsGenerated: number, agentsGenerated: numbe...
    method displayError (line 153) | displayError(message: string, error?: Error): void {
    method displayInfo (line 165) | displayInfo(title: string, message: string): void {
    method displaySuccess (line 173) | displaySuccess(message: string): void {
    method displayWarning (line 177) | displayWarning(message: string): void {
    method displayStep (line 181) | displayStep(step: number, total: number, description: string): void {
    method formatBytes (line 188) | formatBytes(bytes: number): string {
    method t (line 196) | private t(key: TranslationKey, params?: TranslateParams): string {

FILE: src/utils/fileMapper.ts
  class FileMapper (line 7) | class FileMapper {
    method constructor (line 23) | constructor(customExcludes: string[] = []) {
    method loadGitignorePatterns (line 28) | private async loadGitignorePatterns(repoPath: string): Promise<string[...
    method mapRepository (line 40) | async mapRepository(repoPath: string, includePatterns?: string[]): Pro...
    method readFileContent (line 122) | async readFileContent(filePath: string): Promise<string> {
    method getFilesByExtension (line 130) | getFilesByExtension(files: FileInfo[], extension: string): FileInfo[] {
    method isTextFile (line 134) | isTextFile(filePath: string): boolean {
    method extractTopLevelSegment (line 147) | private extractTopLevelSegment(relativePath: string): string | null {

FILE: src/utils/frontMatter.ts
  type FrontMatter (line 16) | interface FrontMatter {
  type ParsedScaffoldFrontmatter (line 25) | interface ParsedScaffoldFrontmatter {
  function isScaffoldFrontmatter (line 48) | function isScaffoldFrontmatter(fm: FrontMatter | ParsedScaffoldFrontmatt...
  constant FRONT_MATTER_DELIMITER (line 52) | const FRONT_MATTER_DELIMITER = '---';
  function needsFill (line 59) | async function needsFill(filePath: string): Promise<boolean> {
  function readFirstLines (line 88) | async function readFirstLines(filePath: string, n: number): Promise<stri...
  function parseFrontMatter (line 113) | function parseFrontMatter(content: string): { frontMatter: FrontMatter |...
  function addFrontMatter (line 144) | function addFrontMatter(content: string, frontMatter: FrontMatter): stri...
  function removeFrontMatter (line 162) | function removeFrontMatter(content: string): string {
  function hasFrontMatter (line 170) | function hasFrontMatter(content: string): boolean {
  function createUnfilledFrontMatter (line 177) | function createUnfilledFrontMatter(): FrontMatter {
  function getUnfilledFiles (line 187) | async function getUnfilledFiles(contextDir: string): Promise<string[]> {
  function getFilledStats (line 204) | async function getFilledStats(contextDir: string): Promise<{
  function parseScaffoldFrontMatter (line 231) | function parseScaffoldFrontMatter(content: string): {
  function getDocumentName (line 350) | function getDocumentName(content: string): string | null {
  function isScaffoldContent (line 369) | function isScaffoldContent(content: string): boolean {

FILE: src/utils/gitService.ts
  type GitChanges (line 7) | interface GitChanges {
  type GitState (line 14) | interface GitState {
  type CommitResult (line 18) | interface CommitResult {
  class GitService (line 24) | class GitService {
    method constructor (line 28) | constructor(repoPath: string) {
    method isGitRepository (line 33) | isGitRepository(): boolean {
    method getCurrentCommit (line 45) | getCurrentCommit(): string {
    method getChangedFiles (line 56) | getChangedFiles(since?: string): GitChanges {
    method getStagedFiles (line 133) | getStagedFiles(): string[] {
    method getStagedChanges (line 146) | getStagedChanges(): GitChanges {
    method getUncommittedChanges (line 194) | getUncommittedChanges(): GitChanges {
    method getBranchName (line 246) | getBranchName(): string {
    method getLastProcessedCommit (line 257) | getLastProcessedCommit(): string | null {
    method saveState (line 269) | saveState(commit: string): void {
    method getState (line 285) | getState(): GitState | null {
    method clearState (line 296) | clearState(): void {
    method filterRelevantFiles (line 306) | filterRelevantFiles(files: string[], fileMapper: any): string[] {
    method isFileTracked (line 313) | isFileTracked(filePath: string): boolean {
    method getTrackedFiles (line 325) | getTrackedFiles(): string[] {
    method filterTrackedFiles (line 338) | filterTrackedFiles(files: string[]): string[] {
    method getCommitMessage (line 343) | getCommitMessage(commit: string): string {
    method getFileHistory (line 354) | getFileHistory(filePath: string, limit: number = 10): Array<{ commit: ...
    method getAllTrackedFilesAsAdded (line 375) | private getAllTrackedFilesAsAdded(): GitChanges {
    method isValidCommit (line 395) | isValidCommit(commit: string): boolean {
    method getUnstagedFiles (line 410) | getUnstagedFiles(): string[] {
    method stageFiles (line 428) | stageFiles(patterns: string[]): string[] {
    method commit (line 459) | commit(message: string, coAuthor?: string): CommitResult {
    method hasUncommittedChanges (line 498) | hasUncommittedChanges(): boolean {
    method getCommitsBetween (line 511) | getCommitsBetween(fromCommit: string, toCommit: string = 'HEAD'): stri...
    method getCommitInfo (line 524) | getCommitInfo(commit: string): { hash: string; shortHash: string; mess...
    method displayCommitTrackingInfo (line 538) | displayCommitTrackingInfo(verbose: boolean = false): void {
    method hasContextBeenInitialized (line 576) | hasContextBeenInitialized(outputDir: string): boolean {

FILE: src/utils/gitignoreManager.ts
  constant DEFAULT_EXCLUDE_PATTERNS (line 19) | const DEFAULT_EXCLUDE_PATTERNS: readonly string[] = [
  type GitIgnoreManagerOptions (line 30) | interface GitIgnoreManagerOptions {
  class GitIgnoreManager (line 37) | class GitIgnoreManager {
    method constructor (line 42) | constructor(private readonly options: GitIgnoreManagerOptions = {}) {
    method loadFromRepo (line 53) | async loadFromRepo(repoPath: string): Promise<void> {
    method shouldIgnore (line 91) | shouldIgnore(relativePath: string): boolean {
    method filterPaths (line 117) | filterPaths(relativePaths: string[]): string[] {
    method isLoaded (line 124) | get isLoaded(): boolean {
    method clearCache (line 131) | clearCache(): void {
    method parseGitignore (line 139) | private parseGitignore(content: string): string[] {
    method applyDefaults (line 149) | private applyDefaults(): void {
  type EnsureGitignorePatternsOptions (line 156) | interface EnsureGitignorePatternsOptions {
  function normalizeGitignorePattern (line 160) | function normalizeGitignorePattern(pattern: string): string {
  function ensureGitignorePatterns (line 173) | async function ensureGitignorePatterns(

FILE: src/utils/i18n.ts
  type Locale (line 1) | type Locale = 'en' | 'pt-BR';
  constant SUPPORTED_LOCALES (line 3) | const SUPPORTED_LOCALES: Locale[] = ['en', 'pt-BR'];
  constant DEFAULT_LOCALE (line 4) | const DEFAULT_LOCALE: Locale = 'en';
  type TranslationKey (line 551) | type TranslationKey = keyof typeof englishMessages;
  type TranslationDictionary (line 553) | type TranslationDictionary = Record<TranslationKey, string>;
  type TranslateParams (line 1105) | type TranslateParams = Record<string, string | number | undefined>;
  type TranslateFn (line 1107) | type TranslateFn = (key: TranslationKey, params?: TranslateParams) => st...
  function createTranslator (line 1109) | function createTranslator(locale: Locale): TranslateFn {
  function normalizeLocale (line 1119) | function normalizeLocale(locale: string): Locale {
  function detectLocale (line 1123) | function detectLocale(
  function extractLocaleFromArgs (line 1144) | function extractLocaleFromArgs(argv: string[]): string | undefined {
  function fillTemplate (line 1160) | function fillTemplate(template: string, params?: TranslateParams): string {
  function isSupportedLocale (line 1170) | function isSupportedLocale(locale: string): boolean {
  function resolveLocaleCandidate (line 1174) | function resolveLocaleCandidate(locale?: string | null): Locale | undefi...

FILE: src/utils/pathSecurity.ts
  class SecurityError (line 21) | class SecurityError extends Error {
    method constructor (line 25) | constructor(message: string, attemptedPath: string, workspaceRoot: str...
  class PathValidator (line 39) | class PathValidator {
    method constructor (line 42) | constructor(private readonly workspaceRoot: string) {
    method validatePath (line 53) | validatePath(inputPath: string): string {
    method isWithinBoundary (line 91) | isWithinBoundary(resolvedPath: string): boolean {
    method safeResolve (line 102) | safeResolve(inputPath: string): string | null {
    method hasUrlEncodedTraversal (line 113) | private hasUrlEncodedTraversal(input: string): boolean {

FILE: src/utils/processShutdown.ts
  type ShutdownTarget (line 1) | interface ShutdownTarget {
  type ShutdownController (line 5) | interface ShutdownController {
  type ShutdownControllerOptions (line 10) | interface ShutdownControllerOptions {
  function registerProcessShutdown (line 22) | function registerProcessShutdown(

FILE: src/utils/prompts/configSummary.ts
  function displayConfigSummary (line 8) | function displayConfigSummary(summary: ConfigSummary, _t: TranslateFn): ...

FILE: src/utils/prompts/index.ts
  function promptInteractiveMode (line 16) | async function promptInteractiveMode(t: TranslateFn): Promise<Interactiv...
  function promptAnalysisOptions (line 32) | async function promptAnalysisOptions(
  function promptConfirmProceed (line 90) | async function promptConfirmProceed(t: TranslateFn): Promise<boolean> {
  function promptLoadEnv (line 100) | async function promptLoadEnv(t: TranslateFn): Promise<boolean> {

FILE: src/utils/prompts/smartDefaults.ts
  function detectSmartDefaults (line 8) | async function detectSmartDefaults(basePath?: string): Promise<SmartDefa...
  function detectProjectLanguages (line 29) | async function detectProjectLanguages(repoPath: string): Promise<string[...

FILE: src/utils/prompts/types.ts
  type InteractiveMode (line 1) | type InteractiveMode = 'quick' | 'advanced';
  type PathsPromptResult (line 3) | interface PathsPromptResult {
  type SmartDefaults (line 8) | interface SmartDefaults {
  type ConfigSummary (line 15) | interface ConfigSummary {
  type AnalysisOptions (line 25) | interface AnalysisOptions {

FILE: src/utils/splashScreen.test.ts
  function stripAnsi (line 10) | function stripAnsi(value: string): string {

FILE: src/utils/splashScreen.ts
  type SplashScreenLine (line 7) | interface SplashScreenLine {
  type SplashScreenOptions (line 13) | interface SplashScreenOptions {
  function renderSplashScreen (line 19) | function renderSplashScreen(options: SplashScreenOptions): string {
  function packageNameToDisplayName (line 41) | function packageNameToDisplayName(packageName: string): string {
  function formatSplashDirectory (line 57) | function formatSplashDirectory(directory: string, maxLength = 48): string {
  function formatLine (line 69) | function formatLine(line: SplashScreenLine, labelWidth: number): string {
  function truncateMiddle (line 80) | function truncateMiddle(value: string, maxLength: number): string {

FILE: src/utils/themedPrompt.ts
  type Choice (line 9) | type Choice<V> = {
  function themedSelect (line 18) | async function themedSelect<V>(config: {
  function themedConfirm (line 31) | async function themedConfirm(config: {
  function themedInput (line 41) | async function themedInput(config: {
  function themedPassword (line 52) | async function themedPassword(config: {
  function themedCheckbox (line 62) | async function themedCheckbox<V>(config: {

FILE: src/utils/versionChecker.ts
  type VersionCheckOptions (line 6) | interface VersionCheckOptions {
  constant DEFAULT_TIMEOUT_MS (line 17) | const DEFAULT_TIMEOUT_MS = 2000;
  constant DISABLE_ENV_FLAGS (line 19) | const DISABLE_ENV_FLAGS = ['DOTCONTEXT_DISABLE_UPDATE_CHECK', 'NO_UPDATE...
  function fetchLatestVersion (line 21) | async function fetchLatestVersion(packageName: string, timeoutMs: number...
  function checkForUpdates (line 45) | async function checkForUpdates(options: VersionCheckOptions): Promise<vo...

FILE: src/version.ts
  constant VERSION (line 15) | const VERSION: string = pkg.version;
  constant PACKAGE_NAME (line 16) | const PACKAGE_NAME: string = pkg.name;

FILE: src/workflow/agents/agentRegistry.ts
  constant BUILT_IN_AGENTS (line 14) | const BUILT_IN_AGENTS = [
  type BuiltInAgentType (line 31) | type BuiltInAgentType = (typeof BUILT_IN_AGENTS)[number];
  type AgentMetadata (line 36) | interface AgentMetadata {
  type DiscoveredAgents (line 48) | interface DiscoveredAgents {
  function isBuiltInAgent (line 57) | function isBuiltInAgent(agentType: string): agentType is BuiltInAgentType {
  class AgentRegistry (line 67) | class AgentRegistry {
    method constructor (line 71) | constructor(repoPath: string) {
    method discoverAll (line 78) | async discoverAll(): Promise<DiscoveredAgents> {
    method discoverBuiltIn (line 92) | async discoverBuiltIn(): Promise<AgentMetadata[]> {
    method discoverCustom (line 106) | async discoverCustom(): Promise<AgentMetadata[]> {
    method getAgentMetadata (line 137) | async getAgentMetadata(agentType: string): Promise<AgentMetadata> {
    method agentExists (line 171) | async agentExists(agentType: string): Promise<boolean> {
    method getPlaybookContent (line 179) | async getPlaybookContent(agentType: string): Promise<string | null> {
    method clearCache (line 192) | clearCache(): void {
    method extractMetadataFromFile (line 199) | private async extractMetadataFromFile(
  function createAgentRegistry (line 220) | function createAgentRegistry(repoPath: string): AgentRegistry {

FILE: src/workflow/collaboration.ts
  function generateSessionId (line 20) | function generateSessionId(): string {
  class CollaborationSession (line 29) | class CollaborationSession {
    method constructor (line 37) | constructor(topic: string, participants?: PrevcRole[]) {
    method getId (line 49) | getId(): string {
    method start (line 56) | async start(
    method getStatus (line 72) | getStatus(): CollaborationStatus {
    method contribute (line 85) | contribute(role: PrevcRole, message: string): void {
    method getContributions (line 106) | getContributions(): Contribution[] {
    method getContributionsByRole (line 113) | getContributionsByRole(role: PrevcRole): Contribution[] {
    method synthesize (line 120) | async synthesize(): Promise<CollaborationSynthesis> {
    method extractDecisions (line 140) | private async extractDecisions(): Promise<string[]> {
    method generateRecommendations (line 175) | private async generateRecommendations(): Promise<string[]> {
    method selectRelevantRoles (line 219) | private async selectRelevantRoles(topic: string): Promise<PrevcRole[]> {
    method getDurationMinutes (line 283) | getDurationMinutes(): number {
    method getParticipantNames (line 292) | getParticipantNames(): string[] {
    method isParticipant (line 299) | isParticipant(role: PrevcRole): boolean {
    method addParticipant (line 306) | addParticipant(role: PrevcRole): void {
    method removeParticipant (line 315) | removeParticipant(role: PrevcRole): void {
  class CollaborationManager (line 325) | class CollaborationManager {
    method createSession (line 331) | createSession(topic: string, participants?: PrevcRole[]): Collaboratio...
    method getSession (line 340) | getSession(id: string): CollaborationSession | undefined {
    method getActiveSessions (line 347) | getActiveSessions(): CollaborationSession[] {
    method endSession (line 356) | async endSession(id: string): Promise<CollaborationSynthesis | null> {
    method clearConcludedSessions (line 369) | clearConcludedSessions(): void {

FILE: src/workflow/errors.ts
  class WorkflowError (line 12) | class WorkflowError extends Error {
    method constructor (line 13) | constructor(message: string) {
  class WorkflowGateError (line 22) | class WorkflowGateError extends WorkflowError {
    method constructor (line 30) | constructor(options: {
  class NoPlanToApproveError (line 47) | class NoPlanToApproveError extends WorkflowError {
    method constructor (line 48) | constructor(message = 'No plan is linked to approve. Link a plan first...
  class NoWorkflowError (line 57) | class NoWorkflowError extends WorkflowError {
    method constructor (line 58) | constructor(message = 'No workflow found. Run workflowInit first.') {

FILE: src/workflow/gates/gateChecker.test.ts
  function createMockStatus (line 9) | function createMockStatus(overrides: Partial<PrevcStatus> = {}): PrevcSt...

FILE: src/workflow/gates/gateChecker.ts
  type GateStatus (line 19) | interface GateStatus {
  type GateCheckResult (line 29) | interface GateCheckResult {
  function getDefaultSettings (line 45) | function getDefaultSettings(scale: ProjectScale | string): WorkflowSetti...
  class WorkflowGateChecker (line 77) | class WorkflowGateChecker {
    method checkGates (line 81) | checkGates(
    method enforceGates (line 171) | enforceGates(
    method getEffectiveSettings (line 197) | private getEffectiveSettings(status: PrevcStatus): WorkflowSettings {
    method hasLinkedPlan (line 215) | private hasLinkedPlan(status: PrevcStatus): boolean {
    method isPlanApproved (line 237) | private isPlanApproved(status: PrevcStatus): boolean {
    method getNextPhase (line 244) | private getNextPhase(current: PrevcPhase): PrevcPhase | null {
  function createGateChecker (line 252) | function createGateChecker(): WorkflowGateChecker {

FILE: src/workflow/orchestration/agentOrchestrator.ts
  constant AGENT_TYPES (line 14) | const AGENT_TYPES = [
  type AgentType (line 31) | type AgentType = (typeof AGENT_TYPES)[number];
  constant PHASE_TO_AGENTS (line 36) | const PHASE_TO_AGENTS: Record<PrevcPhase, AgentType[]> = {
  constant ROLE_TO_AGENTS (line 59) | const ROLE_TO_AGENTS: Record<PrevcRole, AgentType[]> = {
  constant TASK_KEYWORDS (line 86) | const TASK_KEYWORDS: Record<string, AgentType[]> = {
  class AgentOrchestrator (line 168) | class AgentOrchestrator {
    method getAgentsForPhase (line 172) | getAgentsForPhase(phase: PrevcPhase): AgentType[] {
    method getAgentsForRole (line 179) | getAgentsForRole(role: PrevcRole): AgentType[] {
    method getPrimaryAgentForRole (line 186) | getPrimaryAgentForRole(role: PrevcRole): AgentType | null {
    method selectAgentsByTask (line 194) | selectAgentsByTask(taskDescription: string): AgentType[] {
    method getAgentHandoffSequence (line 216) | getAgentHandoffSequence(phases: PrevcPhase[]): AgentType[] {
    method getTaskAgentSequence (line 236) | getTaskAgentSequence(
    method specialistToAgent (line 264) | specialistToAgent(specialist: string): AgentType | null {
    method getAllAgentTypes (line 284) | getAllAgentTypes(): AgentType[] {
    method isValidAgentType (line 291) | isValidAgentType(type: string): type is AgentType {
    method getAgentDescription (line 298) | getAgentDescription(agent: AgentType): string {

FILE: src/workflow/orchestration/documentLinker.ts
  type DocType (line 14) | type DocType =
  type DocGuide (line 29) | interface DocGuide {
  constant DOCUMENT_GUIDES (line 39) | const DOCUMENT_GUIDES: DocGuide[] = [
  constant AGENT_TO_DOCS (line 105) | const AGENT_TO_DOCS: Record<AgentType, DocType[]> = {
  constant PHASE_TO_DOCS (line 125) | const PHASE_TO_DOCS: Record<PrevcPhase, DocType[]> = {
  constant ROLE_TO_DOCS (line 136) | const ROLE_TO_DOCS: Record<PrevcRole, DocType[]> = {
  class DocumentLinker (line 150) | class DocumentLinker {
    method getDocsForAgent (line 154) | getDocsForAgent(agent: AgentType): DocGuide[] {
    method getDocsForPhase (line 162) | getDocsForPhase(phase: PrevcPhase): DocGuide[] {
    method getDocsForRole (line 170) | getDocsForRole(role: PrevcRole): DocGuide[] {
    method getPrimaryDocForAgent (line 178) | getPrimaryDocForAgent(agent: AgentType): DocGuide | null {
    method getAllDocs (line 186) | getAllDocs(): DocGuide[] {
    method getDocByType (line 193) | getDocByType(type: DocType): DocGuide | null {
    method getDocPathsForAgent (line 200) | getDocPathsForAgent(agent: AgentType): string[] {
    method getDocPathsForPhase (line 207) | getDocPathsForPhase(phase: PrevcPhase): string[] {
    method getDocPathsForRole (line 214) | getDocPathsForRole(role: PrevcRole): string[] {
    method getDocsForAgents (line 221) | getDocsForAgents(agents: AgentType[]): DocGuide[] {
    method getDocsForTask (line 235) | getDocsForTask(taskDescription: string): DocGuide[] {
    method generateAgentDocLinks (line 277) | generateAgentDocLinks(agent: AgentType): string {
    method generatePhaseDocLinks (line 291) | generatePhaseDocLinks(phase: PrevcPhase): string {
    method getGuidesByTypes (line 305) | private getGuidesByTypes(types: DocType[]): DocGuide[] {

FILE: src/workflow/orchestrator.ts
  type CompletePhaseOptions (line 32) | interface CompletePhaseOptions {
  type InitWorkflowOptions (line 40) | interface InitWorkflowOptions {
  class PrevcOrchestrator (line 52) | class PrevcOrchestrator {
    method constructor (line 59) | constructor(contextPath: string) {
    method hasWorkflow (line 71) | async hasWorkflow(): Promise<boolean> {
    method initWorkflow (line 78) | async initWorkflow(context: ProjectContext): Promise<PrevcStatus> {
    method initWorkflowWithScale (line 98) | async initWorkflowWithScale(
    method resetWorkflow (line 138) | async resetWorkflow(archive: boolean): Promise<void> {
    method archiveCurrentWorkflow (line 151) | private async archiveCurrentWorkflow(): Promise<void> {
    method initWorkflowWithOptions (line 170) | async initWorkflowWithOptions(options: InitWorkflowOptions): Promise<P...
    method getStatus (line 177) | async getStatus(): Promise<PrevcStatus> {
    method getCurrentPhase (line 184) | async getCurrentPhase(): Promise<PrevcPhase> {
    method getCurrentRole (line 191) | async getCurrentRole(): Promise<PrevcRole | null> {
    method getCurrentPhaseDefinition (line 198) | async getCurrentPhaseDefinition() {
    method handoff (line 209) | async handoff(
    method getNextAgentSuggestion (line 229) | getNextAgentSuggestion(currentAgent: string): { agent: string; reason:...
    method getPhaseOrchestration (line 249) | async getPhaseOrchestration(phase: PrevcPhase): Promise<PhaseOrchestra...
    method getAgentDefaultTask (line 291) | private getAgentDefaultTask(agent: string): string {
    method buildToolGuidance (line 315) | private buildToolGuidance(phase: PrevcPhase, startAgent: string): Tool...
    method buildOrchestrationSteps (line 326) | private buildOrchestrationSteps(phase: PrevcPhase, agents: string[]): ...
    method buildOrchestrationInstruction (line 343) | private buildOrchestrationInstruction(phase: PrevcPhase, startAgent: s...
    method completePhase (line 368) | async completePhase(
    method checkGates (line 407) | async checkGates(): Promise<GateCheckResult> {
    method setSettings (line 415) | async setSettings(settings: Partial<WorkflowSettings>): Promise<Workfl...
    method getSettings (line 422) | async getSettings(): Promise<WorkflowSettings> {
    method markPlanCreated (line 429) | async markPlanCreated(planSlug: string): Promise<void> {
    method approvePlan (line 436) | async approvePlan(approver: PrevcRole | string, notes?: string): Promi...
    method getApproval (line 443) | async getApproval(): Promise<PlanApproval | undefined> {
    method advanceToNextPhase (line 450) | async advanceToNextPhase(): Promise<PrevcPhase | null> {
    method getNextPhase (line 461) | async getNextPhase(): Promise<PrevcPhase | null> {
    method isComplete (line 468) | async isComplete(): Promise<boolean> {
    method getRecommendedActions (line 475) | async getRecommendedActions(): Promise<string[]> {
    method getSummary (line 507) | async getSummary(): Promise<WorkflowSummary> {
    method updateCurrentTask (line 541) | async updateCurrentTask(task: string): Promise<void> {
    method startRole (line 554) | async startRole(role: PrevcRole): Promise<void> {
    method completeRole (line 570) | async completeRole(role: PrevcRole, outputs: string[]): Promise<void> {
  type WorkflowSummary (line 582) | interface WorkflowSummary {

FILE: src/workflow/phases.ts
  constant PREVC_PHASE_ORDER (line 17) | const PREVC_PHASE_ORDER: PrevcPhase[] = ['P', 'R', 'E', 'V', 'C'];
  constant PREVC_PHASES (line 22) | const PREVC_PHASES: Record<PrevcPhase, PhaseDefinition> = {
  constant PHASE_NAMES (line 68) | const PHASE_NAMES: Record<PrevcPhase, string> = {
  constant PHASE_NAMES_EN (line 79) | const PHASE_NAMES_EN = PHASE_NAMES;
  constant PHASE_NAMES_PT (line 84) | const PHASE_NAMES_PT: Record<PrevcPhase, string> = {
  function getPhaseDefinition (line 95) | function getPhaseDefinition(phase: PrevcPhase): PhaseDefinition {
  function getNextPhase (line 102) | function getNextPhase(currentPhase: PrevcPhase): PrevcPhase | null {
  function getPreviousPhase (line 113) | function getPreviousPhase(currentPhase: PrevcPhase): PrevcPhase | null {
  function isPhaseOptional (line 124) | function isPhaseOptional(phase: PrevcPhase): boolean {
  function getRolesForPhase (line 131) | function getRolesForPhase(phase: PrevcPhase): string[] {
  function getOutputsForPhase (line 138) | function getOutputsForPhase(phase: PrevcPhase): string[] {
  function isValidPhase (line 145) | function isValidPhase(phase: string): phase is PrevcPhase {
  function getPhaseOrder (line 152) | function getPhaseOrder(phase: PrevcPhase): number {

FILE: src/workflow/plans/planLinker.ts
  class PlanLinker (line 37) | class PlanLinker {
    method constructor (line 46) | constructor(repoPath: string, statusManager?: PrevcStatusManager, auto...
    method create (line 59) | static async create(
    method ensureWorkflowPlanIndex (line 70) | async ensureWorkflowPlanIndex(): Promise<void> {
    method discoverAgents (line 86) | async discoverAgents(): Promise<Array<{ type: string; path: string; is...
    method getAgentInfo (line 99) | async getAgentInfo(agentType: string): Promise<AgentMetadata> {
    method linkPlan (line 106) | async linkPlan(planSlug: string): Promise<PlanReference | null> {
    method getLinkedPlans (line 134) | async getLinkedPlans(): Promise<WorkflowPlans> {
    method updatePlanReference (line 152) | async updatePlanReference(
    method getLinkedPlan (line 183) | async getLinkedPlan(planSlug: string): Promise<LinkedPlan | null> {
    method getPlansForPhase (line 203) | async getPlansForPhase(phase: PrevcPhase): Promise<LinkedPlan[]> {
    method updatePlanPhase (line 223) | async updatePlanPhase(
    method recordDecision (line 280) | async recordDecision(
    method getPhaseMappingForWorkflow (line 328) | getPhaseMappingForWorkflow(plan: LinkedPlan, currentPrevcPhase: PrevcP...
    method hasPendingWorkForPhase (line 335) | hasPendingWorkForPhase(plan: LinkedPlan, phase: PrevcPhase): boolean {
    method getPlanProgress (line 343) | async getPlanProgress(planSlug: string): Promise<{
    method updatePlanStep (line 382) | async updatePlanStep(
    method updatePlanApproval (line 501) | async updatePlanApproval(
    method getPlanExecutionStatus (line 558) | async getPlanExecutionStatus(planSlug: string): Promise<PlanExecutionT...
    method syncPlanMarkdown (line 566) | async syncPlanMarkdown(planSlug: string): Promise<boolean> {
    method recordPhaseCommit (line 592) | async recordPhaseCommit(
    method loadPlanTracking (line 638) | private async loadPlanTracking(planSlug: string): Promise<PlanExecutio...
    method calculateStepProgress (line 682) | private calculateStepProgress(tracking: PlanExecutionTracking): number {
    method updateFrontmatterProgress (line 697) | private updateFrontmatterProgress(content: string, tracking: PlanExecu...
    method updateStepCheckboxes (line 736) | private updateStepCheckboxes(content: string, tracking: PlanExecutionT...
    method updateExecutionHistorySection (line 789) | private updateExecutionHistorySection(content: string, tracking: PlanE...
    method generateExecutionHistoryMarkdown (line 833) | private generateExecutionHistoryMarkdown(tracking: PlanExecutionTracki...
    method parsePlanFile (line 892) | private parsePlanFile(content: string, slug: string): { title: string;...
    method parseFrontMatter (line 905) | private parseFrontMatter(content: string): {
    method parsePlanToLinked (line 1003) | private parsePlanToLinked(content: string, ref: PlanReference): Linked...
    method extractPhasesFromBody (line 1049) | private extractPhasesFromBody(content: string): PlanPhase[] {
    method extractDecisions (line 1096) | private extractDecisions(): PlanDecision[] {
    method extractAgentsFromBody (line 1104) | private extractAgentsFromBody(content: string): string[] {
    method extractDocsFromBody (line 1124) | private extractDocsFromBody(content: string): string[] {
    method addPlanToWorkflow (line 1144) | private async addPlanToWorkflow(ref: PlanReference): Promise<void> {
    method clearAllPlans (line 1188) | async clearAllPlans(): Promise<void> {
    method archivePlans (line 1207) | async archivePlans(): Promise<void> {
    method autoCommitPhase (line 1242) | private async autoCommitPhase(planSlug: string, phaseId: string): Prom...
  function createPlanLinker (line 1308) | function createPlanLinker(repoPath: string, statusManager?: PrevcStatusM...

FILE: src/workflow/plans/types.ts
  constant PLAN_PHASE_TO_PREVC (line 13) | const PLAN_PHASE_TO_PREVC: Record<string, PrevcPhase> = {
  type PlanReference (line 29) | interface PlanReference {
  type PlanStep (line 53) | interface PlanStep {
  type PlanPhase (line 71) | interface PlanPhase {
  type PlanDecision (line 93) | interface PlanDecision {
  type PlanRisk (line 117) | interface PlanRisk {
  type AgentLineupEntry (line 137) | interface AgentLineupEntry {
  type LinkedPlan (line 147) | interface LinkedPlan {
  type WorkflowPlans (line 171) | interface WorkflowPlans {
  type PlanSyncEvent (line 183) | interface PlanSyncEvent {
  type StepExecution (line 199) | interface StepExecution {
  type PlanPhaseTracking (line 219) | interface PlanPhaseTracking {
  type PlanExecutionTracking (line 244) | interface PlanExecutionTracking {

FILE: src/workflow/prevcConfig.ts
  constant ROLE_CONFIG (line 12) | const ROLE_CONFIG: Record<PrevcRole, RoleDefinition> = {
  function getRoleConfig (line 129) | function getRoleConfig(role: PrevcRole): RoleDefinition {
  function getRolesForPhase (line 136) | function getRolesForPhase(phase: string): PrevcRole[] {
  function getOutputsForRole (line 150) | function getOutputsForRole(role: PrevcRole): string[] {
  function getResponsibilitiesForRole (line 157) | function getResponsibilitiesForRole(role: PrevcRole): string[] {

FILE: src/workflow/roles.ts
  constant PREVC_ROLES (line 13) | const PREVC_ROLES = [
  constant ROLE_TO_SPECIALISTS (line 29) | const ROLE_TO_SPECIALISTS: Record<PrevcRole, string[]> = {
  constant SPECIALIST_TO_ROLE (line 51) | const SPECIALIST_TO_ROLE: Record<string, PrevcRole> = {
  constant ROLE_DISPLAY_NAMES (line 71) | const ROLE_DISPLAY_NAMES: Record<PrevcRole, string> = {
  constant ROLE_DISPLAY_NAMES_EN (line 85) | const ROLE_DISPLAY_NAMES_EN = ROLE_DISPLAY_NAMES;
  constant ROLE_DISPLAY_NAMES_PT (line 90) | const ROLE_DISPLAY_NAMES_PT: Record<PrevcRole, string> = {
  function isValidRole (line 104) | function isValidRole(role: string): role is PrevcRole {
  function getRoleForSpecialist (line 112) | function getRoleForSpecialist(specialist: string): PrevcRole | null {
  function getSpecialistsForRole (line 120) | function getSpecialistsForRole(role: PrevcRole): string[] {

FILE: src/workflow/scaling.ts
  constant SCALE_ROUTES (line 13) | const SCALE_ROUTES: Record<ProjectScale, ScaleRoute> = {
  constant BUG_FIX_KEYWORDS (line 40) | const BUG_FIX_KEYWORDS = [
  constant SIMPLE_FEATURE_KEYWORDS (line 55) | const SIMPLE_FEATURE_KEYWORDS = [
  constant SECURITY_KEYWORDS (line 70) | const SECURITY_KEYWORDS = [
  constant DOCUMENTATION_KEYWORDS (line 86) | const DOCUMENTATION_KEYWORDS = [
  function isBugFix (line 100) | function isBugFix(description: string): boolean {
  function isSimpleFeature (line 108) | function isSimpleFeature(description: string): boolean {
  function requiresSecurityAudit (line 116) | function requiresSecurityAudit(description: string): boolean {
  function requiresDocumentation (line 124) | function requiresDocumentation(description: string): boolean {
  function detectProjectScale (line 132) | function detectProjectScale(context: ProjectContext): ProjectScale {
  function getScaleRoute (line 163) | function getScaleRoute(scale: ProjectScale): ScaleRoute {
  function getPhasesForScale (line 170) | function getPhasesForScale(scale: ProjectScale): PrevcPhase[] {
  function getRolesForScale (line 177) | function getRolesForScale(scale: ProjectScale): PrevcRole[] | 'all' {
  function isPhaseRequiredForScale (line 184) | function isPhaseRequiredForScale(
  function getScaleName (line 194) | function getScaleName(scale: ProjectScale): string {
  function getScaleFromName (line 208) | function getScaleFromName(name: string): ProjectScale | null {
  function getEstimatedTime (line 222) | function getEstimatedTime(scale: ProjectScale): string {

FILE: src/workflow/skills/frontmatter.ts
  function generateFrontmatter (line 14) | function generateFrontmatter(metadata: SkillMetadata, slug?: string): st...
  function generatePortableFrontmatter (line 41) | function generatePortableFrontmatter(name: string, description: string):...
  function wrapWithFrontmatter (line 48) | function wrapWithFrontmatter(metadata: SkillMetadata, content: string, s...
  function wrapWithPortableFrontmatter (line 56) | function wrapWithPortableFrontmatter(name: string, description: string, ...
  function parseFrontmatter (line 64) | function parseFrontmatter(content: string): { metadata: SkillMetadata; b...
  function stripQuotes (line 117) | function stripQuotes(value: string): string {
  function parsePhaseArray (line 124) | function parsePhaseArray(value: string): PrevcPhase[] {

FILE: src/workflow/skills/skillRegistry.ts
  constant SKILLS_DIR (line 24) | const SKILLS_DIR = '.context/skills';
  constant AGENTS_SKILLS_DIR (line 27) | const AGENTS_SKILLS_DIR = '.agents/skills';
  class SkillRegistry (line 29) | class SkillRegistry {
    method constructor (line 34) | constructor(repoPath: string) {
    method discoverAll (line 42) | async discoverAll(): Promise<DiscoveredSkills> {
    method getSkillMetadata (line 62) | async getSkillMetadata(slug: string): Promise<Skill | null> {
    method getSkillContent (line 70) | async getSkillContent(slug: string): Promise<string | null> {
    method getSkillsForPhase (line 89) | async getSkillsForPhase(phase: PrevcPhase): Promise<Skill[]> {
    method clearCache (line 97) | clearCache(): void {
    method discoverBuiltInSkills (line 104) | private discoverBuiltInSkills(): Skill[] {
    method discoverCustomSkills (line 132) | private discoverCustomSkills(): Skill[] {
    method discoverSkillsFromDirectory (line 149) | private discoverSkillsFromDirectory(
    method parseSkillFile (line 188) | private parseSkillFile(skillPath: string, slug: string, isBuiltIn: boo...
    method discoverResources (line 218) | private discoverResources(skillDir: string): string[] {
    method discoverResourcesRecursive (line 242) | private discoverResourcesRecursive(dir: string): string[] {
    method createBuiltInSkill (line 266) | private createBuiltInSkill(
  function createSkillRegistry (line 290) | function createSkillRegistry(repoPath: string): SkillRegistry {

FILE: src/workflow/skills/skillTemplates.ts
  type SkillTemplate (line 29) | interface SkillTemplate {
  function contentToMarkdown (line 34) | function contentToMarkdown(title: string, overview: string, content: Ski...
  function extractTriggerBullets (line 53) | function extractTriggerBullets(whenToUse?: string): string[] {
  function joinNaturalLanguage (line 66) | function joinNaturalLanguage(items: string[]): string {
  function buildTemplateDescription (line 79) | function buildTemplateDescription(baseDescription: string, content: Skil...
  function getBuiltInSkillTemplates (line 91) | function getBuiltInSkillTemplates(): Record<BuiltInSkillType, SkillTempl...
  function createCommitMessageSkill (line 106) | function createCommitMessageSkill(): SkillTemplate {
  function createPrReviewSkill (line 114) | function createPrReviewSkill(): SkillTemplate {
  function createCodeReviewSkill (line 122) | function createCodeReviewSkill(): SkillTemplate {
  function createTestGenerationSkill (line 130) | function createTestGenerationSkill(): SkillTemplate {
  function createDocumentationSkill (line 138) | function createDocumentationSkill(): SkillTemplate {
  function createRefactoringSkill (line 146) | function createRefactoringSkill(): SkillTemplate {
  function createBugInvestigationSkill (line 154) | function createBugInvestigationSkill(): SkillTemplate {
  function createFeatureBreakdownSkill (line 162) | function createFeatureBreakdownSkill(): SkillTemplate {
  function createApiDesignSkill (line 170) | function createApiDesignSkill(): SkillTemplate {
  function createSecurityAuditSkill (line 178) | function createSecurityAuditSkill(): SkillTemplate {

FILE: src/workflow/skills/types.ts
  type SkillMetadata (line 14) | interface SkillMetadata {
  type Skill (line 30) | interface Skill {
  type SkillReference (line 48) | interface SkillReference {
  type DiscoveredSkills (line 59) | interface DiscoveredSkills {
  constant BUILT_IN_SKILLS (line 68) | const BUILT_IN_SKILLS = [
  type BuiltInSkillType (line 81) | type BuiltInSkillType = (typeof BUILT_IN_SKILLS)[number];
  function isBuiltInSkill (line 86) | function isBuiltInSkill(skillType: string): skillType is BuiltInSkillType {
  constant SKILL_TO_PHASES (line 93) | const SKILL_TO_PHASES: Record<BuiltInSkillType, PrevcPhase[]> = {

FILE: src/workflow/status/statusManager.ts
  class PrevcStatusManager (line 38) | class PrevcStatusManager {
    method constructor (line 43) | constructor(contextPath: string) {
    method legacyStatusPath (line 48) | private get legacyStatusPath(): string {
    method exists (line 55) | async exists(): Promise<boolean> {
    method load (line 62) | async load(): Promise<PrevcStatus> {
    method loadSync (line 90) | loadSync(): PrevcStatus {
    method save (line 118) | async save(status: PrevcStatus): Promise<void> {
    method remove (line 123) | async remove(): Promise<void> {
    method archive (line 131) | async archive(name: string): Promise<void> {
    method persistCanonical (line 143) | private async persistCanonical(status: PrevcStatus): Promise<void> {
    method create (line 153) | async create(options: {
    method updatePhase (line 177) | async updatePhase(phase: PrevcPhase, update: PhaseUpdate): Promise<voi...
    method updateRole (line 192) | async updateRole(role: PrevcRole, update: RoleUpdate): Promise<void> {
    method updateAgent (line 210) | async updateAgent(agentName: string, update: AgentUpdate): Promise<voi...
    method transitionToPhase (line 245) | async transitionToPhase(phase: PrevcPhase): Promise<void> {
    method markPhaseComplete (line 281) | async markPhaseComplete(
    method getCurrentPhase (line 322) | async getCurrentPhase(): Promise<PrevcPhase> {
    method getActiveRole (line 330) | async getActiveRole(): Promise<PrevcRole | null> {
    method getNextPhase (line 345) | async getNextPhase(): Promise<PrevcPhase | null> {
    method isComplete (line 364) | async isComplete(): Promise<boolean> {
    method setSettings (line 383) | async setSettings(settings: Partial<WorkflowSettings>): Promise<Workfl...
    method getSettings (line 402) | async getSettings(): Promise<WorkflowSettings> {
    method markPlanCreated (line 411) | async markPlanCreated(planSlug: string): Promise<void> {
    method approvePlan (line 448) | async approvePlan(approver: PrevcRole | string, notes?: string): Promi...
    method getApproval (line 490) | async getApproval(): Promise<PlanApproval | undefined> {
    method addHistoryEntry (line 498) | async addHistoryEntry(entry: Omit<ExecutionHistoryEntry, 'timestamp'>)...
    method addStepHistoryEntry (line 526) | async addStepHistoryEntry(entry: {
    method getExecutionHistory (line 573) | async getExecutionHistory(): Promise<ExecutionHistory | undefined> {
    method migrateStatus (line 585) | private migrateStatus(status: PrevcStatus): PrevcStatus {
    method parseYaml (line 673) | private parseYaml(content: string): PrevcStatus {
    method serializeYaml (line 886) | private serializeYaml(status: PrevcStatus): string {

FILE: src/workflow/status/templates.ts
  constant PHASE_NAMES (line 21) | const PHASE_NAMES: Record<PrevcPhase, string> = {
  type StepContext (line 32) | interface StepContext {
  function generateResumeContext (line 41) | function generateResumeContext(
  type CreateStatusOptions (line 87) | interface CreateStatusOptions {
  function createInitialStatus (line 97) | function createInitialStatus(options: CreateStatusOptions): PrevcStatus {
  function createQuickFlowStatus (line 156) | function createQuickFlowStatus(name: string): PrevcStatus {
  function createSmallProjectStatus (line 168) | function createSmallProjectStatus(name: string): PrevcStatus {
  function createMediumProjectStatus (line 180) | function createMediumProjectStatus(name: string): PrevcStatus {
  function createLargeProjectStatus (line 192) | function createLargeProjectStatus(name: string): PrevcStatus {

FILE: src/workflow/types.ts
  type PrevcPhase (line 15) | type PrevcPhase = 'P' | 'R' | 'E' | 'V' | 'C';
  type PrevcRole (line 20) | type PrevcRole =
  type ProjectScale (line 33) | enum ProjectScale {
  type StatusType (line 43) | type StatusType = 'pending' | 'in_progress' | 'completed' | 'skipped';
  type PhaseDefinition (line 48) | interface PhaseDefinition {
  type RoleDefinition (line 60) | interface RoleDefinition {
  type ScaleRoute (line 70) | interface ScaleRoute {
  type PhaseStatus (line 81) | interface PhaseStatus {
  type OutputStatus (line 94) | interface OutputStatus {
  type RoleStatus (line 103) | interface RoleStatus {
  type AgentStatus (line 114) | interface AgentStatus {
  type WorkflowPlanRef (line 124) | interface WorkflowPlanRef {
  type WorkflowSettings (line 133) | interface WorkflowSettings {
  type GateType (line 145) | type GateType = 'plan_required' | 'approval_required';
  type PlanApproval (line 150) | interface PlanApproval {
  type ExecutionAction (line 166) | type ExecutionAction =
  type ExecutionHistoryEntry (line 184) | interface ExecutionHistoryEntry {
  type ExecutionHistory (line 207) | interface ExecutionHistory {
  type ProjectMetadata (line 216) | interface ProjectMetadata {
  type PrevcStatus (line 232) | interface PrevcStatus {
  type ProjectContext (line 248) | interface ProjectContext {
  type PhaseUpdate (line 259) | interface PhaseUpdate {
  type RoleUpdate (line 270) | interface RoleUpdate {
  type AgentUpdate (line 281) | interface AgentUpdate {
  type Contribution (line 289) | interface Contribution {
  type CollaborationStatus (line 298) | interface CollaborationStatus {
  type CollaborationSynthesis (line 309) | interface CollaborationSynthesis {
  type AgentSequenceStep (line 320) | interface AgentSequenceStep {
  type SkillSuggestion (line 328) | interface SkillSuggestion {
  type ToolGuidance (line 339) | interface ToolGuidance {
  type PhaseOrchestration (line 351) | interface PhaseOrchestration {

[
  {
    "path": ".context/agents/README.md",
    "chars": 2599,
    "preview": "# Agent Handbook\n\nThis directory contains ready-to-customize playbooks for AI agents collaborating on the current dotcon"
  },
  {
    "path": ".context/agents/bug-fixer.md",
    "chars": 5627,
    "preview": "---\ntype: agent\nname: bug-fixer\ndescription: Analyze bug reports and error messages\nrole: developer\ngenerated: 2026-03-1"
  },
  {
    "path": ".context/agents/code-reviewer.md",
    "chars": 6305,
    "preview": "---\ntype: agent\nname: code-reviewer\ndescription: Review code changes for quality, style, and best practices\nrole: review"
  },
  {
    "path": ".context/agents/documentation-writer.md",
    "chars": 6629,
    "preview": "---\ntype: agent\nname: documentation-writer\ndescription: Create clear, comprehensive documentation\nrole: documenter\ngener"
  },
  {
    "path": ".context/agents/feature-developer.md",
    "chars": 6584,
    "preview": "---\ntype: agent\nname: feature-developer\ndescription: Implement new features according to specifications\nrole: developer\n"
  },
  {
    "path": ".context/agents/performance-optimizer.md",
    "chars": 6611,
    "preview": "---\ntype: agent\nname: performance-optimizer\ndescription: Identify performance bottlenecks\nrole: developer\ngenerated: 202"
  },
  {
    "path": ".context/agents/refactoring-specialist.md",
    "chars": 6832,
    "preview": "---\ntype: agent\nname: refactoring-specialist\ndescription: Identify code smells and improvement opportunities\nrole: devel"
  },
  {
    "path": ".context/agents/test-writer.md",
    "chars": 7530,
    "preview": "---\ntype: agent\nname: test-writer\ndescription: Write comprehensive unit and integration tests\nrole: qa\ngenerated: 2026-0"
  },
  {
    "path": ".context/docs/README.md",
    "chars": 1752,
    "preview": "# Documentation Index\n\nWelcome to the `@dotcontext/cli` repository knowledge base. Start with the project overview, then"
  },
  {
    "path": ".context/docs/codebase-map.json",
    "chars": 42469,
    "preview": "{\n  \"version\": \"1.0.0\",\n  \"generated\": \"2026-03-18T21:32:49.263Z\",\n  \"stack\": {\n    \"primaryLanguage\": \"typescript\",\n   "
  },
  {
    "path": ".context/docs/development-workflow.md",
    "chars": 4660,
    "preview": "---\ntype: doc\nname: development-workflow\ndescription: Day-to-day engineering processes, branching, and contribution guid"
  },
  {
    "path": ".context/docs/harness-roadmap.md",
    "chars": 8265,
    "preview": "---\ntype: doc\nname: harness-roadmap\ndescription: Product roadmap for evolving dotcontext into a harness engineering plat"
  },
  {
    "path": ".context/docs/harness-split-foundation.md",
    "chars": 18404,
    "preview": "---\ntype: doc\nname: harness-split-foundation\ndescription: Detailed explanation of the first internal split between the C"
  },
  {
    "path": ".context/docs/project-overview.md",
    "chars": 6004,
    "preview": "---\ntype: doc\nname: project-overview\ndescription: High-level overview of the project, its purpose, and key components\nca"
  },
  {
    "path": ".context/docs/qa/README.md",
    "chars": 435,
    "preview": "# Q&A Index\n\nProject type: **cli-tool**\n\nGenerated: 2026-03-18T21:32:55.004Z\n\n## Getting-started\n\n- [How do I set up and"
  },
  {
    "path": ".context/docs/qa/error-handling.md",
    "chars": 3414,
    "preview": "---\nslug: error-handling\ncategory: operations\nstatus: filled\ngeneratedAt: 2026-03-18T21:32:54.231Z\nrelevantFiles:\n  - sr"
  },
  {
    "path": ".context/docs/qa/getting-started.md",
    "chars": 2335,
    "preview": "---\nslug: getting-started\ncategory: getting-started\nstatus: filled\ngeneratedAt: 2026-03-18T21:32:50.399Z\n---\n\n# How do I"
  },
  {
    "path": ".context/docs/qa/project-structure.md",
    "chars": 4016,
    "preview": "---\nslug: project-structure\ncategory: architecture\nstatus: filled\ngeneratedAt: 2026-03-18T21:32:54.231Z\nrelevantFiles:\n "
  },
  {
    "path": ".context/docs/testing-strategy.md",
    "chars": 5068,
    "preview": "---\ntype: doc\nname: testing-strategy\ndescription: Test frameworks, patterns, coverage requirements, and quality gates\nca"
  },
  {
    "path": ".context/docs/tooling.md",
    "chars": 6913,
    "preview": "---\ntype: doc\nname: tooling\ndescription: Scripts, IDE settings, automation, and developer productivity tips\ncategory: to"
  },
  {
    "path": ".context/skills/README.md",
    "chars": 3408,
    "preview": "# Skills\n\nOn-demand expertise for AI agents. Skills are task-specific procedures that get activated when relevant.\n\n> Pr"
  },
  {
    "path": ".context/skills/api-design/SKILL.md",
    "chars": 6156,
    "preview": "---\ntype: skill\nname: MCP Tool Design\ndescription: Design MCP tools and gateway interfaces for the dotcontext server\nski"
  },
  {
    "path": ".context/skills/bug-investigation/SKILL.md",
    "chars": 6170,
    "preview": "---\ntype: skill\nname: Bug Investigation\ndescription: Systematic bug investigation and root cause analysis\nskillSlug: bug"
  },
  {
    "path": ".context/skills/code-review/SKILL.md",
    "chars": 5706,
    "preview": "---\ntype: skill\nname: Code Review\ndescription: Review code quality, patterns, and best practices\nskillSlug: code-review\n"
  },
  {
    "path": ".context/skills/commit-message/SKILL.md",
    "chars": 5455,
    "preview": "---\ntype: skill\nname: Commit Message\ndescription: Generate commit messages following conventional commits with scope det"
  },
  {
    "path": ".context/skills/documentation/SKILL.md",
    "chars": 5371,
    "preview": "---\ntype: skill\nname: Documentation\ndescription: Generate and update technical documentation\nskillSlug: documentation\nph"
  },
  {
    "path": ".context/skills/feature-breakdown/SKILL.md",
    "chars": 6073,
    "preview": "---\ntype: skill\nname: Feature Breakdown\ndescription: Break down features into implementable tasks\nskillSlug: feature-bre"
  },
  {
    "path": ".context/skills/pr-review/SKILL.md",
    "chars": 5116,
    "preview": "---\ntype: skill\nname: PR Review\ndescription: Review pull requests against team standards and best practices\nskillSlug: p"
  },
  {
    "path": ".context/skills/refactoring/SKILL.md",
    "chars": 6082,
    "preview": "---\ntype: skill\nname: Refactoring\ndescription: Safe code refactoring with step-by-step approach\nskillSlug: refactoring\np"
  },
  {
    "path": ".context/skills/security-audit/SKILL.md",
    "chars": 5716,
    "preview": "---\ntype: skill\nname: Security Audit\ndescription: Security review checklist for code and infrastructure\nskillSlug: secur"
  },
  {
    "path": ".context/skills/test-generation/SKILL.md",
    "chars": 7087,
    "preview": "---\ntype: skill\nname: Test Generation\ndescription: Generate comprehensive test cases for code\nskillSlug: test-generation"
  },
  {
    "path": ".env.example",
    "chars": 265,
    "preview": "# OpenRouter API Configuration\nOPENROUTER_API_KEY=your_openrouter_api_key_here\n\n# Optional: Override default model\n# OPE"
  },
  {
    "path": ".github/PULL_REQUEST_BODY.md",
    "chars": 525,
    "preview": "## Summary\n\n<!-- Brief description of what this PR does and why -->\n\n## Changes\n\n<!-- List the key changes -->\n\n-\n\n## Br"
  },
  {
    "path": ".github/workflows/ci.yml",
    "chars": 1937,
    "preview": "name: CI\n\non:\n  push:\n    branches: [ main, develop ]\n  pull_request:\n    branches: [ main ]\n\njobs:\n  test:\n    runs-on:"
  },
  {
    "path": ".github/workflows/release.yml",
    "chars": 1564,
    "preview": "name: Release\n\non:\n  push:\n    tags:\n      - 'v*'\n  workflow_dispatch:\n\njobs:\n  verify-mcp-package:\n    runs-on: ubuntu-"
  },
  {
    "path": ".gitignore",
    "chars": 691,
    "preview": "# Dependencies\nnode_modules/\n\n# Build output\ndist/\n*.tsbuildinfo\n\n# Environment files\n.env\n.env.*\n!.env.example\n\n# Logs\n"
  },
  {
    "path": ".npmignore",
    "chars": 399,
    "preview": "# Source files\nsrc/\n*.ts\n\n# Configuration files\ntsconfig.json\n.env\n.env.*\n!.env.example\n\n# Development files\nnode_module"
  },
  {
    "path": "AGENTS.md",
    "chars": 1372,
    "preview": "# Dotcontext Agent Instructions\n\nThis repository exposes one runtime through three surfaces:\n\n```text\ncli -> harness <- "
  },
  {
    "path": "ARCHITECTURE.md",
    "chars": 6071,
    "preview": "# Dotcontext Harness Architecture\n\nThis document explains how dotcontext works as a harness engineering runtime, how the"
  },
  {
    "path": "CHANGELOG.md",
    "chars": 71222,
    "preview": "# Changelog\n\nAll notable changes to this project will be documented in this file.\n\nThe format is based on [Keep a Change"
  },
  {
    "path": "CLAUDE.md",
    "chars": 1550,
    "preview": "# Dotcontext Repository Guide\n\nThis repository is the source for the dotcontext runtime and its operator/adaptor surface"
  },
  {
    "path": "CONTRIBUTING.md",
    "chars": 3936,
    "preview": "# Contributing to dotcontext\n\nDotcontext is now organized around an explicit runtime split:\n\n```text\ncli -> harness <- m"
  },
  {
    "path": "CONVENTIONS.md",
    "chars": 2005,
    "preview": "# Project Rules and Guidelines\n\n> Auto-generated from .context/docs on 2026-03-18T21:47:40.751Z\n\n## README\n\n# Documentat"
  },
  {
    "path": "LICENSE",
    "chars": 1073,
    "preview": "MIT License\n\nCopyright (c) 2024 AI Coders Academy\n\nPermission is hereby granted, free of charge, to any person obtaining"
  },
  {
    "path": "README.md",
    "chars": 24738,
    "preview": "# @dotcontext/cli\n\n[![npm version](https://badge.fury.io/js/@dotcontext%2Fcli.svg)](https://www.npmjs.com/package/@dotco"
  },
  {
    "path": "docs/CONTEXT-WORKFLOW-HARNESS-CLI-PTBR.md",
    "chars": 14801,
    "preview": "# Guia Educativo: Contexto, Workflow, Harness e CLI no Dotcontext\n\nEste material explica como o dotcontext organiza cont"
  },
  {
    "path": "docs/GUIDE.md",
    "chars": 10036,
    "preview": "# Dotcontext Guide\n\n`dotcontext` ships separate CLI and MCP package surfaces for shared AI context, PREVC workflow track"
  },
  {
    "path": "example-documentation.ts",
    "chars": 1176,
    "preview": "/**\n * Example script demonstrating how to scaffold documentation and agent playbooks\n * programmatically without going "
  },
  {
    "path": "jest.config.js",
    "chars": 542,
    "preview": "/** @type {import('jest').Config} */\nmodule.exports = {\n  preset: 'ts-jest',\n  testEnvironment: 'node',\n  roots: ['<root"
  },
  {
    "path": "package.json",
    "chars": 2742,
    "preview": "{\n  \"name\": \"@dotcontext/cli\",\n  \"version\": \"0.9.2\",\n  \"description\": \"Harness engineering runtime for AI-assisted softw"
  },
  {
    "path": "prompts/update_plan_prompt.md",
    "chars": 2555,
    "preview": "# Prompt: Update Collaboration Plans\n\n## Purpose\nYou are an AI assistant responsible for refining collaboration plans th"
  },
  {
    "path": "prompts/update_scaffold_prompt.md",
    "chars": 1235,
    "preview": "# Prompt: Update Repository Documentation and Agent Playbooks\n\n## Purpose\nYou are an AI assistant responsible for refres"
  },
  {
    "path": "scripts/build-package-bundles.js",
    "chars": 5647,
    "preview": "#!/usr/bin/env node\n\nconst fs = require('fs');\nconst path = require('path');\n\nconst repoRoot = path.resolve(__dirname, '"
  },
  {
    "path": "scripts/release-packages.js",
    "chars": 3071,
    "preview": "#!/usr/bin/env node\n\nconst fs = require('fs');\nconst path = require('path');\nconst semver = require('semver');\nconst { e"
  },
  {
    "path": "scripts/smoke-package-bundles.js",
    "chars": 4152,
    "preview": "#!/usr/bin/env node\n\nconst fs = require('fs');\nconst path = require('path');\nconst { execFileSync } = require('child_pro"
  },
  {
    "path": "scripts/test-mcp.js",
    "chars": 2000,
    "preview": "#!/usr/bin/env node\n/**\n * Simple MCP test client for local development\n *\n * Usage: node scripts/test-mcp.js\n */\n\nconst"
  },
  {
    "path": "src/cli/index.test.ts",
    "chars": 712,
    "preview": "import {\n  MCPInstallService,\n  SyncService,\n  ImportRulesService,\n  ImportAgentsService,\n  ExportRulesService,\n  Report"
  },
  {
    "path": "src/cli/index.ts",
    "chars": 1073,
    "preview": "/**\n * CLI boundary exports.\n *\n * This module defines the operator-facing surface that is expected to\n * become the fut"
  },
  {
    "path": "src/cli.test.ts",
    "chars": 2645,
    "preview": "import { execSync } from 'child_process';\nimport * as path from 'path';\n\ndescribe('CLI Commands', () => {\n  const cliPat"
  },
  {
    "path": "src/generators/agents/agentConfig.ts",
    "chars": 6687,
    "preview": "import { AgentType } from './agentTypes';\n\nexport const AGENT_RESPONSIBILITIES: Record<AgentType, string[]> = {\n  'code-"
  },
  {
    "path": "src/generators/agents/agentGenerator.test.ts",
    "chars": 3509,
    "preview": "import * as os from 'os';\nimport * as path from 'path';\nimport * as fs from 'fs-extra';\n\nimport { AgentGenerator } from "
  },
  {
    "path": "src/generators/agents/agentGenerator.ts",
    "chars": 12426,
    "preview": "import * as path from 'path';\nimport { RepoStructure } from '../../types';\nimport { GeneratorUtils } from '../shared';\ni"
  },
  {
    "path": "src/generators/agents/agentTypes.ts",
    "chars": 615,
    "preview": "export const AGENT_TYPES = [\n  'code-reviewer',\n  'bug-fixer',\n  'feature-developer',\n  'refactoring-specialist',\n  'tes"
  },
  {
    "path": "src/generators/agents/index.ts",
    "chars": 201,
    "preview": "export { AgentGenerator } from './agentGenerator';\nexport { AGENT_TYPES, AgentType, IMPORTANT_FILES } from './agentTypes"
  },
  {
    "path": "src/generators/agents/templates/index.ts",
    "chars": 120,
    "preview": "export { renderAgentIndex } from './indexTemplate';\nexport type { AgentTemplateContext, DocTouchpoint } from './types';\n"
  },
  {
    "path": "src/generators/agents/templates/indexTemplate.ts",
    "chars": 1224,
    "preview": "import { AgentType } from '../agentTypes';\nimport { AGENT_RESPONSIBILITIES } from '../agentConfig';\n\nexport function ren"
  },
  {
    "path": "src/generators/agents/templates/types.ts",
    "chars": 534,
    "preview": "import { AgentType } from '../agentTypes';\nimport { SemanticContext } from '../../../services/semantic';\n\nexport interfa"
  },
  {
    "path": "src/generators/documentation/codebaseMapGenerator.ts",
    "chars": 23908,
    "preview": "/**\n * Codebase Map Generator\n *\n * Generates a summary JSON file for the codebase structure, stack,\n * architecture, de"
  },
  {
    "path": "src/generators/documentation/documentationGenerator.test.ts",
    "chars": 4596,
    "preview": "import * as os from 'os';\nimport * as path from 'path';\nimport * as fs from 'fs-extra';\n\nimport { DocumentationGenerator"
  },
  {
    "path": "src/generators/documentation/documentationGenerator.ts",
    "chars": 11257,
    "preview": "import * as path from 'path';\nimport * as fs from 'fs-extra';\nimport { RepoStructure } from '../../types';\nimport { Gene"
  },
  {
    "path": "src/generators/documentation/guideRegistry.ts",
    "chars": 2112,
    "preview": "import { GuideMeta } from './templates/types';\n\nexport const DOCUMENT_GUIDES: GuideMeta[] = [\n  {\n    key: 'project-over"
  },
  {
    "path": "src/generators/documentation/index.ts",
    "chars": 261,
    "preview": "export { DocumentationGenerator } from './documentationGenerator';\nexport { CodebaseMapGenerator } from './codebaseMapGe"
  },
  {
    "path": "src/generators/documentation/templates/common.ts",
    "chars": 5654,
    "preview": "import * as path from 'path';\nimport { DirectoryStat, DocumentationTemplateContext } from './types';\nimport type { Extra"
  },
  {
    "path": "src/generators/documentation/templates/index.ts",
    "chars": 134,
    "preview": "export { renderIndex } from './indexTemplate';\nexport type { DocumentationTemplateContext, GuideMeta, DirectoryStat } fr"
  },
  {
    "path": "src/generators/documentation/templates/indexTemplate.ts",
    "chars": 821,
    "preview": "import { buildDocumentMapTable, formatDirectoryList } from './common';\nimport { DocumentationTemplateContext } from './t"
  },
  {
    "path": "src/generators/documentation/templates/types.ts",
    "chars": 558,
    "preview": "import { RepoStructure } from '../../../types';\nimport { SemanticContext } from '../../../services/semantic';\n\nexport in"
  },
  {
    "path": "src/generators/plans/index.ts",
    "chars": 49,
    "preview": "export { PlanGenerator } from './planGenerator';\n"
  },
  {
    "path": "src/generators/plans/planGenerator.test.ts",
    "chars": 2431,
    "preview": "import * as os from 'os';\nimport * as path from 'path';\nimport * as fs from 'fs-extra';\n\nimport { PlanGenerator } from '"
  },
  {
    "path": "src/generators/plans/planGenerator.ts",
    "chars": 5252,
    "preview": "import * as path from 'path';\nimport * as fs from 'fs-extra';\n\nimport { GeneratorUtils } from '../shared';\nimport { Agen"
  },
  {
    "path": "src/generators/plans/templates/indexTemplate.ts",
    "chars": 908,
    "preview": "import { PlanIndexEntry } from './types';\n\nexport function renderPlanIndex(entries: PlanIndexEntry[]): string {\n  const "
  },
  {
    "path": "src/generators/plans/templates/planTemplate.ts",
    "chars": 11181,
    "preview": "/**\n * REFERENCE ONLY - This file is not used by generators anymore.\n *\n * Scaffold structures are now defined in:\n * sr"
  },
  {
    "path": "src/generators/plans/templates/types.ts",
    "chars": 719,
    "preview": "import { AgentType } from '../../agents/agentTypes';\nimport { GuideMeta } from '../../documentation/templates/types';\nim"
  },
  {
    "path": "src/generators/shared/contextGenerator.ts",
    "chars": 270,
    "preview": "import { FileMapper } from '../../utils/fileMapper';\n\nexport class ContextGenerator {\n  constructor(protected readonly f"
  },
  {
    "path": "src/generators/shared/directoryTemplateHelpers.ts",
    "chars": 290,
    "preview": "export function formatDirectoryList(directories: string[], placeholderMessage?: string): string {\n  if (!directories.len"
  },
  {
    "path": "src/generators/shared/generatorUtils.ts",
    "chars": 2948,
    "preview": "import * as fs from 'fs-extra';\nimport * as path from 'path';\nimport { RepoStructure } from '../../types';\nimport { colo"
  },
  {
    "path": "src/generators/shared/index.ts",
    "chars": 275,
    "preview": "export { GeneratorUtils } from './generatorUtils';\nexport { ContextGenerator } from './contextGenerator';\nexport { forma"
  },
  {
    "path": "src/generators/shared/scaffoldStructures.ts",
    "chars": 469,
    "preview": "/**\n * Scaffold Structure Definitions (DEPRECATED)\n *\n * This file is maintained for backward compatibility.\n * All func"
  },
  {
    "path": "src/generators/shared/structures/agents/definitions.ts",
    "chars": 26594,
    "preview": "/**\n * Agent structure definitions with static default content\n */\n\nimport { createAgentStructure, AgentDefaultContent }"
  },
  {
    "path": "src/generators/shared/structures/agents/factory.ts",
    "chars": 4654,
    "preview": "/**\n * Factory function for creating agent structures\n */\n\nimport { ScaffoldStructure, ScaffoldSection } from '../types'"
  },
  {
    "path": "src/generators/shared/structures/agents/index.ts",
    "chars": 526,
    "preview": "/**\n * Agent structure exports\n */\n\nexport { createAgentStructure } from './factory';\nexport {\n  codeReviewerStructure,\n"
  },
  {
    "path": "src/generators/shared/structures/documentation/apiReference.ts",
    "chars": 3911,
    "preview": "import { ScaffoldStructure } from '../types';\n\nexport const apiReferenceStructure: ScaffoldStructure = {\n  fileType: 'do"
  },
  {
    "path": "src/generators/shared/structures/documentation/architecture.ts",
    "chars": 6881,
    "preview": "import { ScaffoldStructure } from '../types';\n\nconst SEMANTIC_SNAPSHOT_GUIDANCE =\n  'Use `context({ action: \"getMap\", se"
  },
  {
    "path": "src/generators/shared/structures/documentation/dataFlow.ts",
    "chars": 3496,
    "preview": "import { ScaffoldStructure } from '../types';\n\nexport const dataFlowStructure: ScaffoldStructure = {\n  fileType: 'doc',\n"
  },
  {
    "path": "src/generators/shared/structures/documentation/glossary.ts",
    "chars": 2933,
    "preview": "import { ScaffoldStructure } from '../types';\n\nexport const glossaryStructure: ScaffoldStructure = {\n  fileType: 'doc',\n"
  },
  {
    "path": "src/generators/shared/structures/documentation/index.ts",
    "chars": 689,
    "preview": "/**\n * Documentation structure definitions\n */\n\nexport { projectOverviewStructure } from './projectOverview';\nexport { a"
  },
  {
    "path": "src/generators/shared/structures/documentation/migration.ts",
    "chars": 4056,
    "preview": "import { ScaffoldStructure } from '../types';\n\nexport const migrationStructure: ScaffoldStructure = {\n  fileType: 'doc',"
  },
  {
    "path": "src/generators/shared/structures/documentation/onboarding.ts",
    "chars": 4210,
    "preview": "import { ScaffoldStructure } from '../types';\n\nexport const onboardingStructure: ScaffoldStructure = {\n  fileType: 'doc'"
  },
  {
    "path": "src/generators/shared/structures/documentation/projectOverview.ts",
    "chars": 6829,
    "preview": "import { ScaffoldStructure } from '../types';\n\nconst SEMANTIC_SNAPSHOT_GUIDANCE =\n  'Use `context({ action: \"getMap\", se"
  },
  {
    "path": "src/generators/shared/structures/documentation/security.ts",
    "chars": 3380,
    "preview": "import { ScaffoldStructure } from '../types';\n\nexport const securityStructure: ScaffoldStructure = {\n  fileType: 'doc',\n"
  },
  {
    "path": "src/generators/shared/structures/documentation/testing.ts",
    "chars": 4207,
    "preview": "import { ScaffoldStructure } from '../types';\n\nexport const testingStrategyStructure: ScaffoldStructure = {\n  fileType: "
  },
  {
    "path": "src/generators/shared/structures/documentation/tooling.ts",
    "chars": 3549,
    "preview": "import { ScaffoldStructure } from '../types';\n\nexport const toolingStructure: ScaffoldStructure = {\n  fileType: 'doc',\n "
  },
  {
    "path": "src/generators/shared/structures/documentation/troubleshooting.ts",
    "chars": 3875,
    "preview": "import { ScaffoldStructure } from '../types';\n\nexport const troubleshootingStructure: ScaffoldStructure = {\n  fileType: "
  },
  {
    "path": "src/generators/shared/structures/documentation/workflow.ts",
    "chars": 3929,
    "preview": "import { ScaffoldStructure } from '../types';\n\nexport const developmentWorkflowStructure: ScaffoldStructure = {\n  fileTy"
  },
  {
    "path": "src/generators/shared/structures/index.ts",
    "chars": 556,
    "preview": "/**\n * Scaffold structures index\n *\n * This file serves as the main barrel export for all scaffold structures,\n * provid"
  },
  {
    "path": "src/generators/shared/structures/plans/index.ts",
    "chars": 84,
    "preview": "/**\n * Plan structure exports\n */\n\nexport { planStructure } from './planStructure';\n"
  },
  {
    "path": "src/generators/shared/structures/plans/planStructure.ts",
    "chars": 1717,
    "preview": "/**\n * Plan structure definition\n */\n\nimport { ScaffoldStructure } from '../types';\n\nexport const planStructure: Scaffol"
  },
  {
    "path": "src/generators/shared/structures/registry.ts",
    "chars": 3196,
    "preview": "/**\n * Scaffold structures registry and lookup functions\n */\n\nimport { ScaffoldFileType } from '../../../types/scaffoldF"
  },
  {
    "path": "src/generators/shared/structures/serialization.ts",
    "chars": 4522,
    "preview": "/**\n * Serialization functions for scaffold structures\n */\n\nimport { ScaffoldStructure, ScaffoldSection } from './types'"
  },
  {
    "path": "src/generators/shared/structures/skills/definitions.ts",
    "chars": 16262,
    "preview": "/**\n * Skill structure definitions with static default content\n */\n\nimport { createSkillStructure, SkillDefaultContent }"
  },
  {
    "path": "src/generators/shared/structures/skills/factory.ts",
    "chars": 3064,
    "preview": "/**\n * Factory function for creating skill structures\n */\n\nimport { ScaffoldStructure, ScaffoldSection } from '../types'"
  },
  {
    "path": "src/generators/shared/structures/skills/index.ts",
    "chars": 655,
    "preview": "/**\n * Skill structure exports\n */\n\nexport { createSkillStructure } from './factory';\nexport {\n  commitMessageSkillStruc"
  },
  {
    "path": "src/generators/shared/structures/types.ts",
    "chars": 2349,
    "preview": "/**\n * Type definitions for scaffold structures\n */\n\nimport { ScaffoldFileType } from '../../../types/scaffoldFrontmatte"
  },
  {
    "path": "src/generators/shared/structures/validation.ts",
    "chars": 1381,
    "preview": "/**\n * Validation functions for scaffold structures\n */\n\nimport { ScaffoldStructure } from './types';\nimport { SCAFFOLD_"
  },
  {
    "path": "src/generators/skills/index.ts",
    "chars": 314,
    "preview": "/**\n * Skills Generator Module\n */\n\nexport {\n  SkillGenerator,\n  SkillGeneratorOptions,\n  SkillGeneratorResult,\n  create"
  },
  {
    "path": "src/generators/skills/skillGenerator.test.ts",
    "chars": 2046,
    "preview": "import * as os from 'os';\nimport * as path from 'path';\nimport * as fs from 'fs-extra';\n\nimport { SkillGenerator } from "
  },
  {
    "path": "src/generators/skills/skillGenerator.ts",
    "chars": 7361,
    "preview": "/**\n * Skill Generator\n *\n * Scaffolds skill directories and SKILL.md files.\n * Generates scaffold v2 files with fillabl"
  },
  {
    "path": "src/generators/skills/templates/indexTemplate.ts",
    "chars": 3299,
    "preview": "/**\n * Skills Index (README.md) Template\n */\n\nimport { Skill } from '../../../workflow/skills';\n\nexport interface Skills"
  },
  {
    "path": "src/generators/skills/templates/skillTemplate.ts",
    "chars": 2510,
    "preview": "/**\n * SKILL.md Template\n *\n * REFERENCE ONLY - This file is not used by generators anymore.\n *\n * Scaffold structures a"
  },
  {
    "path": "src/harness/index.test.ts",
    "chars": 1216,
    "preview": "import {\n  WorkflowService,\n  HarnessAgentsService,\n  HarnessPlansService,\n  HarnessContextService,\n  HarnessSkillsServi"
  },
  {
    "path": "src/harness/index.ts",
    "chars": 2988,
    "preview": "/**\n * Harness boundary exports.\n *\n * This module defines the reusable runtime surface that is expected to\n * become th"
  },
  {
    "path": "src/index.ts",
    "chars": 43940,
    "preview": "#!/usr/bin/env node\n\nimport { Command } from 'commander';\nimport * as path from 'path';\nimport inquirer from 'inquirer';"
  },
  {
    "path": "src/mcp/bin.test.ts",
    "chars": 3644,
    "preview": "const mockRun = jest.fn();\nconst mockResolveMcpInstallToolSelection = jest.fn();\nconst mockStartMCPServer = jest.fn();\n\n"
  },
  {
    "path": "src/mcp/bin.ts",
    "chars": 6084,
    "preview": "#!/usr/bin/env node\n\n/**\n * Dedicated MCP package binary for `@dotcontext/mcp`.\n *\n * Default behavior starts the MCP se"
  },
  {
    "path": "src/mcp/index.test.ts",
    "chars": 886,
    "preview": "import {\n  AIContextMCPServer,\n  startMCPServer,\n  handleExplore,\n  handleContext,\n  handlePlan,\n  handleAgent,\n  handle"
  },
  {
    "path": "src/mcp/index.ts",
    "chars": 1014,
    "preview": "/**\n * MCP boundary exports.\n *\n * This module defines the protocol adapter surface that is expected to\n * become the fu"
  },
  {
    "path": "src/prompts/defaults.ts",
    "chars": 4094,
    "preview": "export const UPDATE_SCAFFOLD_PROMPT_FALLBACK = `# Prompt: Update Repository Documentation and Agent Playbooks\n\n## Purpos"
  },
  {
    "path": "src/services/autoFill/autoFillService.ts",
    "chars": 19059,
    "preview": "/**\n * AutoFillService - Generates documentation content from semantic analysis\n *\n * This service fills scaffold templa"
  },
  {
    "path": "src/services/autoFill/index.ts",
    "chars": 70,
    "preview": "export { AutoFillService, AutoFillContext } from './autoFillService';\n"
  },
  {
    "path": "src/services/cli/index.ts",
    "chars": 606,
    "preview": "/**\n * CLI service exports.\n *\n * These services belong to the operator-facing CLI boundary.\n */\n\nexport {\n  MCPInstallS"
  },
  {
    "path": "src/services/cli/mcpInstallService.test.ts",
    "chars": 21780,
    "preview": "import * as os from 'os';\nimport * as path from 'path';\nimport * as fs from 'fs-extra';\nimport {\n  MCPInstallService,\n  "
  },
  {
    "path": "src/services/cli/mcpInstallService.ts",
    "chars": 22611,
    "preview": "/**\n * MCP Install Service\n *\n * CLI-facing installation service for configuring the dotcontext MCP server\n * in various"
  },
  {
    "path": "src/services/cli/stateDetector.ts",
    "chars": 5400,
    "preview": "/**\n * StateDetector - Detects the current state of the project's context documentation.\n *\n * States:\n * - new: No .con"
  },
  {
    "path": "src/services/export/contextExportService.ts",
    "chars": 5877,
    "preview": "/**\n * Context Export Service\n *\n * Unified export of docs, agents, and skills to AI tool directories.\n * Orchestrates E"
  },
  {
    "path": "src/services/export/exportRulesService.ts",
    "chars": 10627,
    "preview": "/**\n * Export Rules Service\n *\n * Bidirectional sync: export rules from .context to AI tool directories.\n */\n\nimport * a"
  },
  {
    "path": "src/services/export/index.ts",
    "chars": 597,
    "preview": "export { ExportRulesService, EXPORT_PRESETS } from './exportRulesService';\nexport type { ExportOptions, ExportResult, Ex"
  },
  {
    "path": "src/services/export/skillExportService.test.ts",
    "chars": 1972,
    "preview": "import * as os from 'os';\nimport * as path from 'path';\nimport * as fs from 'fs-extra';\n\nimport { SkillExportService } f"
  },
  {
    "path": "src/services/export/skillExportService.ts",
    "chars": 8813,
    "preview": "/**\n * Skill Export Service\n *\n * Export skills from .context/skills to AI tool skill directories.\n */\n\nimport * as path"
  },
  {
    "path": "src/services/harness/agentsService.ts",
    "chars": 4602,
    "preview": "/**\n * Harness Agents Service\n *\n * Transport-agnostic agent discovery and orchestration logic.\n */\n\nimport {\n  PHASE_NA"
  },
  {
    "path": "src/services/harness/contextService.ts",
    "chars": 18824,
    "preview": "/**\n * Harness Context Service\n *\n * Transport-agnostic context, semantic analysis, and scaffold orchestration logic.\n *"
  },
  {
    "path": "src/services/harness/contextTools.test.ts",
    "chars": 6752,
    "preview": "import * as fs from 'fs-extra';\nimport * as os from 'os';\nimport * as path from 'path';\n\nimport {\n  fillSingleFileTool,\n"
  },
  {
    "path": "src/services/harness/contextTools.ts",
    "chars": 39182,
    "preview": "import * as fs from 'fs-extra';\nimport { glob } from 'glob';\nimport * as path from 'path';\nimport { TreeSitterLayer } fr"
  },
  {
    "path": "src/services/harness/datasetService.test.ts",
    "chars": 2143,
    "preview": "import * as fs from 'fs-extra';\nimport * as os from 'os';\nimport * as path from 'path';\n\nimport { HarnessExecutionServic"
  },
  {
    "path": "src/services/harness/datasetService.ts",
    "chars": 10547,
    "preview": "import * as fs from 'fs-extra';\nimport * as path from 'path';\nimport { randomUUID } from 'crypto';\n\nimport { HarnessRunt"
  },
  {
    "path": "src/services/harness/executionService.test.ts",
    "chars": 1484,
    "preview": "import * as fs from 'fs-extra';\nimport * as os from 'os';\nimport * as path from 'path';\n\nimport { HarnessExecutionServic"
  },
  {
    "path": "src/services/harness/executionService.ts",
    "chars": 9249,
    "preview": "import {\n  HarnessRuntimeStateService,\n  type AddArtifactInput,\n  type AppendTraceInput,\n  type CheckpointInput,\n  type "
  },
  {
    "path": "src/services/harness/index.ts",
    "chars": 3471,
    "preview": "/**\n * Harness service exports.\n *\n * These services hold transport-agnostic harness logic that can be consumed\n * by MC"
  },
  {
    "path": "src/services/harness/plansService.ts",
    "chars": 8502,
    "preview": "/**\n * Harness Plans Service\n *\n * Transport-agnostic plan management and execution tracking logic.\n */\n\nimport * as pat"
  },
  {
    "path": "src/services/harness/policyService.test.ts",
    "chars": 4074,
    "preview": "import * as fs from 'fs-extra';\nimport * as os from 'os';\nimport * as path from 'path';\n\nimport { HarnessPolicyService }"
  },
  {
    "path": "src/services/harness/policyService.ts",
    "chars": 18400,
    "preview": "import * as fs from 'fs-extra';\nimport * as path from 'path';\nimport { StackDetector, type StackInfo } from '../stack';\n"
  },
  {
    "path": "src/services/harness/replayService.test.ts",
    "chars": 2254,
    "preview": "import * as fs from 'fs-extra';\nimport * as os from 'os';\nimport * as path from 'path';\n\nimport { HarnessExecutionServic"
  },
  {
    "path": "src/services/harness/replayService.ts",
    "chars": 9426,
    "preview": "import * as fs from 'fs-extra';\nimport * as path from 'path';\nimport { randomUUID } from 'crypto';\n\nimport type {\n  Harn"
  },
  {
    "path": "src/services/harness/runtimeStateService.test.ts",
    "chars": 3425,
    "preview": "import * as fs from 'fs-extra';\nimport * as os from 'os';\nimport * as path from 'path';\nimport {\n  HarnessRuntimeStateSe"
  },
  {
    "path": "src/services/harness/runtimeStateService.ts",
    "chars": 12361,
    "preview": "/**\n * Harness Runtime State Service\n *\n * Transport-agnostic persistence for sessions, artifacts, traces, and checkpoin"
  },
  {
    "path": "src/services/harness/sensorCatalogService.ts",
    "chars": 9501,
    "preview": "/**\n * Harness Sensor Catalog Service\n *\n * Bootstraps a user-editable sensor catalog under .context/harness/sensors.jso"
  },
  {
    "path": "src/services/harness/sensorsService.test.ts",
    "chars": 1562,
    "preview": "import * as fs from 'fs-extra';\nimport * as os from 'os';\nimport * as path from 'path';\nimport { HarnessRuntimeStateServ"
  },
  {
    "path": "src/services/harness/sensorsService.ts",
    "chars": 4629,
    "preview": "/**\n * Harness Sensors Service\n *\n * Registers and executes quality sensors, then persists the run as a trace\n * entry i"
  },
  {
    "path": "src/services/harness/skillsService.ts",
    "chars": 11437,
    "preview": "/**\n * Harness Skills Service\n *\n * Transport-agnostic skill discovery, export, and fill orchestration logic.\n */\n\nimpor"
  },
  {
    "path": "src/services/harness/taskContractsService.test.ts",
    "chars": 2643,
    "preview": "import * as fs from 'fs-extra';\nimport * as os from 'os';\nimport * as path from 'path';\nimport { HarnessRuntimeStateServ"
  },
  {
    "path": "src/services/harness/taskContractsService.ts",
    "chars": 8885,
    "preview": "/**\n * Harness Task Contracts Service\n *\n * Persists structured task and handoff contracts and evaluates whether a task\n"
  },
  {
    "path": "src/services/harness/workflowStateService.ts",
    "chars": 6918,
    "preview": "/**\n * Harness Workflow State Service\n *\n * Canonical persistence for workflow orchestration state. PREVC status now\n * "
  },
  {
    "path": "src/services/import/agentsDetector.ts",
    "chars": 5155,
    "preview": "import * as path from 'path';\nimport * as fs from 'fs-extra';\nimport { glob } from 'glob';\nimport type { RuleFileInfo, D"
  },
  {
    "path": "src/services/import/importAgentsService.ts",
    "chars": 6960,
    "preview": "import * as path from 'path';\nimport * as fs from 'fs-extra';\n\nimport { colors, symbols, typography } from '../../utils/"
  },
  {
    "path": "src/services/import/importRulesService.ts",
    "chars": 8131,
    "preview": "import * as path from 'path';\nimport * as fs from 'fs-extra';\n\nimport { colors, symbols, typography } from '../../utils/"
  },
  {
    "path": "src/services/import/index.ts",
    "chars": 272,
    "preview": "export * from './types';\nexport * from './presets';\nexport { RulesDetector } from './rulesDetector';\nexport { AgentsDete"
  },
  {
    "path": "src/services/import/presets.ts",
    "chars": 1816,
    "preview": "/**\n * Import Presets\n *\n * Rule and agent source definitions for import/detection services.\n * Derived from the unified"
  },
  {
    "path": "src/services/import/rulesDetector.ts",
    "chars": 9459,
    "preview": "import * as path from 'path';\nimport * as fs from 'fs-extra';\nimport { glob } from 'glob';\nimport type { RuleFileInfo, D"
  },
  {
    "path": "src/services/import/types.ts",
    "chars": 1762,
    "preview": "import type { CLIInterface } from '../../utils/cliUI';\nimport type { TranslateFn } from '../../utils/i18n';\n\nexport type"
  },
  {
    "path": "src/services/mcp/README.md",
    "chars": 4727,
    "preview": "# MCP Tools Reference\n\nThis directory documents the MCP adapter surface over the harness runtime.\n\nCLI-only concerns suc"
  },
  {
    "path": "src/services/mcp/actionLogger.test.ts",
    "chars": 3017,
    "preview": "import * as fs from 'fs-extra';\nimport * as os from 'os';\nimport * as path from 'path';\n\nimport { HarnessRuntimeStateSer"
  },
  {
    "path": "src/services/mcp/actionLogger.ts",
    "chars": 4892,
    "preview": "/**\n * MCP Action Logger\n *\n * Records MCP tool activity into harness session traces instead of maintaining\n * a separat"
  },
  {
    "path": "src/services/mcp/gateway/agent.ts",
    "chars": 1985,
    "preview": "/**\n * Agent Gateway Handler\n *\n * Handles agent orchestration and discovery operations.\n * Replaces: discoverAgents, ge"
  },
  {
    "path": "src/services/mcp/gateway/context.test.ts",
    "chars": 2502,
    "preview": "import * as fs from 'fs-extra';\nimport * as os from 'os';\nimport * as path from 'path';\n\nimport { SemanticContextBuilder"
  },
  {
    "path": "src/services/mcp/gateway/context.ts",
    "chars": 4600,
    "preview": "/**\n * Context Gateway Handler\n *\n * Handles context scaffolding and semantic context operations.\n * Replaces: checkScaf"
  },
  {
    "path": "src/services/mcp/gateway/explore.ts",
    "chars": 2474,
    "preview": "/**\n * Explore Gateway Handler\n *\n * Handles file and code exploration operations.\n * Replaces: readFile, listFiles, ana"
  },
  {
    "path": "src/services/mcp/gateway/harness.test.ts",
    "chars": 5602,
    "preview": "import * as fs from 'fs-extra';\nimport * as os from 'os';\nimport * as path from 'path';\n\nimport { handleHarness } from '"
  },
  {
    "path": "src/services/mcp/gateway/harness.ts",
    "chars": 12183,
    "preview": "import {\n  HarnessExecutionService,\n  HarnessReplayService,\n  HarnessDatasetService,\n  type HarnessPolicyEffect,\n  type "
  },
  {
    "path": "src/services/mcp/gateway/index.ts",
    "chars": 2030,
    "preview": "/**\n * Gateway Tools Module\n *\n * Exports all gateway handlers, types, and response utilities.\n * This module consolidat"
  },
  {
    "path": "src/services/mcp/gateway/metrics.test.ts",
    "chars": 1089,
    "preview": "import {\n  getMetricsSummary,\n  recordFileRead,\n  resetMetrics,\n} from './metrics';\n\ndescribe('metrics recommendations',"
  },
  {
    "path": "src/services/mcp/gateway/metrics.ts",
    "chars": 5004,
    "preview": "/**\n * Metrics Service\n *\n * Tracks context tool usage vs file reads to measure improvement.\n * Helps evaluate the effec"
  },
  {
    "path": "src/services/mcp/gateway/plan.ts",
    "chars": 3051,
    "preview": "/**\n * Plan Gateway Handler\n *\n * Handles plan management and execution tracking operations.\n * Replaces: linkPlan, getL"
  },
  {
    "path": "src/services/mcp/gateway/response.ts",
    "chars": 4028,
    "preview": "/**\n * MCP Response Helpers\n *\n * Standardized response creation for MCP tool handlers.\n */\n\n/**\n * MCP Tool Response ty"
  },
  {
    "path": "src/services/mcp/gateway/shared.ts",
    "chars": 213,
    "preview": "/**\n * Shared Utilities for Gateway Handlers\n *\n * Common utilities used across multiple gateway handlers.\n */\n\nexport {"
  },
  {
    "path": "src/services/mcp/gateway/skill.ts",
    "chars": 1847,
    "preview": "/**\n * Skill Gateway Handler\n *\n * Handles skill management operations.\n * Replaces: listSkills, getSkillContent, getSki"
  },
  {
    "path": "src/services/mcp/gateway/sync.ts",
    "chars": 7644,
    "preview": "/**\n * Sync Gateway Handler\n *\n * Handles import/export synchronization operations.\n * Replaces: exportRules, exportDocs"
  },
  {
    "path": "src/services/mcp/gateway/types.ts",
    "chars": 6888,
    "preview": "/**\n * Gateway Tool Types\n *\n * Type definitions for MCP gateway tool parameters and responses.\n *\n * Note: Some gateway"
  },
  {
    "path": "src/services/mcp/gateway/workflowAdvance.ts",
    "chars": 5561,
    "preview": "/**\n * Workflow Advance Handler\n *\n * Handles advancing PREVC workflow to the next phase.\n */\n\nimport * as path from 'pa"
  },
  {
    "path": "src/services/mcp/gateway/workflowInit.ts",
    "chars": 8212,
    "preview": "/**\n * Workflow Init Handler\n *\n * Handles PREVC workflow initialization.\n * Primary entry point for AI to start workflo"
  },
  {
    "path": "src/services/mcp/gateway/workflowManage.test.ts",
    "chars": 9778,
    "preview": "import * as fs from 'fs-extra';\nimport * as os from 'os';\nimport * as path from 'path';\n\nimport { handlePlan } from './p"
  },
  {
    "path": "src/services/mcp/gateway/workflowManage.ts",
    "chars": 14579,
    "preview": "/**\n * Workflow Manage Handler\n *\n * Handles workflow management operations: handoffs, collaboration, documents, gates, "
  },
  {
    "path": "src/services/mcp/gateway/workflowStatus.test.ts",
    "chars": 1714,
    "preview": "import * as fs from 'fs-extra';\nimport * as os from 'os';\nimport * as path from 'path';\n\nimport { handleWorkflowInit } f"
  },
  {
    "path": "src/services/mcp/gateway/workflowStatus.ts",
    "chars": 2390,
    "preview": "/**\n * Workflow Status Handler\n *\n * Handles PREVC workflow status queries.\n */\n\nimport * as path from 'path';\nimport { "
  },
  {
    "path": "src/services/mcp/gatewayTools.ts",
    "chars": 1811,
    "preview": "/**\n * Gateway Tools\n *\n * Re-exports all gateway handlers, types, and response utilities from the\n * modular gateway di"
  },
  {
    "path": "src/services/mcp/index.ts",
    "chars": 1620,
    "preview": "/**\n * MCP transport adapter exports.\n *\n * Keep this surface focused on the protocol adapter that exposes harness\n * ca"
  },
  {
    "path": "src/services/mcp/mcpInstallService.ts",
    "chars": 376,
    "preview": "/**\n * @deprecated Import from ../cli/mcpInstallService instead.\n *\n * This shim preserves the previous path while the c"
  },
  {
    "path": "src/services/mcp/mcpServer.test.ts",
    "chars": 1815,
    "preview": "import * as os from 'os';\nimport * as path from 'path';\nimport * as fs from 'fs-extra';\nimport { AIContextMCPServer } fr"
  },
  {
    "path": "src/services/mcp/mcpServer.ts",
    "chars": 49946,
    "preview": "/**\n * MCP Server - Model Context Protocol server for dotcontext integration.\n *\n * Exposes consolidated gateway tools p"
  },
  {
    "path": "src/services/qa/index.ts",
    "chars": 346,
    "preview": "/**\n * Q&A Service Module\n *\n * Exports Q&A generation and search functionality.\n */\n\nexport { QAService, type QAEntry, "
  },
  {
    "path": "src/services/qa/patternInferer.ts",
    "chars": 596,
    "preview": "/**\n * Pattern Inferer\n *\n * Backward-compatible adapter for persisted codebase summaries.\n * Functional patterns are no"
  },
  {
    "path": "src/services/qa/qaService.ts",
    "chars": 30394,
    "preview": "/**\n * Q&A Service\n *\n * Generates and manages Q&A content for the codebase.\n * Pre-answers common questions to reduce t"
  },
  {
    "path": "src/services/qa/topicDetector.ts",
    "chars": 10268,
    "preview": "/**\n * Topic Detector Service\n *\n * Dynamically detects Q&A topics based on:\n * 1. Stack detection - Language, framework"
  }
]

// ... and 110 more files (download for full content)