hadara 0.1.0-rc.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ictseoyoungmin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,109 @@
+# HADARA
+
+**HADARA** is a portable agentic development workbench.
+
+> Unbroken Context, Verified Development.
+
+HADARA is named from **Harness + Dara**. A harness safely binds and controls complex systems; Dara carries layered associations of holding, wisdom, durability, and continuity. HADARA binds non-deterministic LLM agent work into a production-oriented workflow through Task Capsules, Session Continuity, Policy Layers, Evidence Logs, and Handoff Protocols.
+
+This repository is a **bootstrap skeleton** for developing HADARA using the HADARA protocol itself.
+
+## Quick Start
+
+```bash
+npm install
+npm run dev -- doctor
+npm run dev -- task create "implement ProviderClient contract"
+npm run dev -- task list
+npm test
+```
+
+Linux/macOS portable launcher:
+
+```bash
+chmod +x ./start.sh
+./start.sh doctor
+```
+
+Windows launcher:
+
+```bat
+START.bat doctor
+```
+
+## Development Principle
+
+HADARA development must dogfood the HADARA workflow:
+
+1. Read `docs/PROJECT_STATE.md`
+2. Read `docs/AGENT_HANDOFF.md`
+3. Read `docs/TASK_BOARD.md`
+4. Work inside a Task Capsule
+5. Attach evidence before marking work complete
+6. Update handoff before stopping
+
+## Store Separation
+
+HADARA separates **portable runtime state** from **project-owned development state**.
+
+### Portable / USB Store
+
+Located under the HADARA installation root:
+
+```text
+data/
+  config/
+  secrets/
+  sessions/
+  logs/
+  audit/
+  cache/
+  exports/
+```
+
+This is **not committed**. It is local, portable, and may live on a USB drive.
+
+### Project Repo Store
+
+Located inside each project repository:
+
+```text
+docs/
+tasks/
+.hadara/
+AGENTS.md
+.hermes.md
+HERMES.md
+```
+
+This is committed when it represents reproducible project state, conventions, or agent context.
+
+## Initial CLI Commands
+
+```bash
+hadara init
+hadara doctor
+hadara task create "..."
+hadara task list
+hadara task show T-0001
+hadara evidence collect --task T-0001
+hadara handoff update --task T-0001
+hadara hermes detect
+hadara hermes export-context
+hadara mcp serve
+```
+
+Current CLI is a seed implementation. Full agent execution, provider integration, dashboard, and MCP server runtime are intentionally stubbed for later tasks.
+
+## Test Suites
+
+```bash
+npm run test:unit
+npm run test:contract
+npm run test:harness
+npm run check
+```
+
+## License
+
+TBD. Recommended candidates: Apache-2.0 or MIT.

package/dist/agent/evidence.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachAgentLoopEvidence = attachAgentLoopEvidence;
+const node_path_1 = __importDefault(require("node:path"));
+const evidence_1 = require("../evidence/evidence");
+function attachAgentLoopEvidence(projectRoot, result) {
+    if (!result.taskId)
+        return [];
+    const fakeShellSteps = result.steps.filter(isFakeShellStep);
+    if (fakeShellSteps.length === 0)
+        return [];
+    const summary = `Agent loop captured ${fakeShellSteps.length} fake-shell observation${fakeShellSteps.length === 1 ? '' : 's'}.`;
+    const appended = (0, evidence_1.appendEvidenceTextArtifact)(projectRoot, {
+        taskId: result.taskId,
+        kind: 'command-log',
+        summary,
+        result: result.ok ? 'passed' : 'failed',
+        visibility: 'public'
+    }, {
+        fileName: 'agent-loop-fake-shell-observations.jsonl',
+        content: `${fakeShellSteps.map((step) => JSON.stringify(toObservationRecord(step))).join('\n')}\n`
+    });
+    return [toAttachment(projectRoot, appended, summary, result.ok ? 'passed' : 'failed')];
+}
+function isFakeShellStep(step) {
+    return step.type === 'tool' && step.tool === 'fake_shell';
+}
+function toObservationRecord(step) {
+    return {
+        step: step.step,
+        tool: step.tool,
+        ok: step.ok,
+        observation: step.observation
+    };
+}
+function toAttachment(projectRoot, appended, summary, result) {
+    return {
+        kind: 'command-log',
+        summary,
+        result,
+        evidencePath: appended.evidence.evidencePath ?? '',
+        markdownPath: toPortablePath(node_path_1.default.relative(projectRoot, appended.markdownPath))
+    };
+}
+function toPortablePath(value) {
+    return value.split(node_path_1.default.sep).join('/');
+}

package/dist/agent/loop.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAgentLoop = runAgentLoop;
+const policy_1 = require("../policy/policy");
+const fake_shell_1 = require("../tools/fake-shell");
+async function runAgentLoop(input) {
+    const mode = (0, policy_1.parsePermissionMode)(input.mode ?? 'assisted');
+    const maxSteps = input.maxSteps ?? 6;
+    const fixtures = input.fakeShellFixtures ?? {};
+    const steps = [];
+    const issues = [];
+    const messages = [
+        {
+            role: 'system',
+            content: 'You are running inside HADARA deterministic harness mode. Request fake shell tools with JSON only.'
+        },
+        { role: 'user', content: input.request }
+    ];
+    for (let step = 1; step <= maxSteps; step += 1) {
+        let response;
+        try {
+            response = await input.provider.chat({ messages });
+        }
+        catch (error) {
+            issues.push({
+                severity: 'error',
+                code: 'AGENT_PROVIDER_FAILED',
+                message: normalizeProviderFailure(input.provider, error).message,
+                step
+            });
+            return {
+                schemaVersion: 'hadara.agent.loop.v1',
+                command: 'agent.loop',
+                ok: false,
+                ...(input.taskId ? { taskId: input.taskId } : {}),
+                mode,
+                request: input.request,
+                steps,
+                issues
+            };
+        }
+        steps.push({ step, type: 'assistant', ok: response.finishReason !== 'error', response });
+        messages.push({ role: 'assistant', content: response.content });
+        const toolRequest = parseFakeShellToolRequest(response.content);
+        if (!toolRequest) {
+            const toolFailed = steps.some((item) => item.type === 'tool' && !item.ok);
+            return {
+                schemaVersion: 'hadara.agent.loop.v1',
+                command: 'agent.loop',
+                ok: !toolFailed && issues.every((issue) => issue.severity !== 'error') && response.finishReason !== 'error',
+                ...(input.taskId ? { taskId: input.taskId } : {}),
+                mode,
+                request: input.request,
+                finalResponse: response.content,
+                steps,
+                issues
+            };
+        }
+        const observation = (0, fake_shell_1.runFakeShellCommand)({
+            command: toolRequest.command,
+            mode,
+            fixtures
+        });
+        steps.push({
+            step,
+            type: 'tool',
+            ok: observation.ok,
+            tool: 'fake_shell',
+            observation
+        });
+        messages.push({ role: 'tool', content: JSON.stringify(observation) });
+        if (!observation.ok) {
+            issues.push({
+                severity: 'error',
+                code: `FAKE_SHELL_${observation.result.status.toUpperCase()}`,
+                message: observation.result.reason ?? observation.result.stderr,
+                step
+            });
+        }
+    }
+    issues.push({
+        severity: 'error',
+        code: 'AGENT_LOOP_MAX_STEPS_EXCEEDED',
+        message: `Agent loop exceeded maxSteps (${maxSteps}) without a final response.`
+    });
+    return {
+        schemaVersion: 'hadara.agent.loop.v1',
+        command: 'agent.loop',
+        ok: false,
+        ...(input.taskId ? { taskId: input.taskId } : {}),
+        mode,
+        request: input.request,
+        steps,
+        issues
+    };
+}
+function parseFakeShellToolRequest(content) {
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== 'object')
+        return null;
+    const record = parsed;
+    if (record.type === 'tool_request' && record.tool === 'fake_shell' && typeof record.command === 'string') {
+        return {
+            type: 'tool_request',
+            tool: 'fake_shell',
+            command: record.command
+        };
+    }
+    return null;
+}
+function normalizeProviderFailure(provider, error) {
+    if (isProviderError(error))
+        return error;
+    return provider.normalizeError(error);
+}
+function isProviderError(error) {
+    return Boolean(error && typeof error === 'object' && 'provider' in error && 'code' in error && 'retriable' in error);
+}

package/dist/cli/args.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliArgsError = void 0;
+exports.getStringOption = getStringOption;
+exports.getRequiredStringOption = getRequiredStringOption;
+exports.getIntegerOption = getIntegerOption;
+exports.getFlag = getFlag;
+exports.rejectMissingValue = rejectMissingValue;
+exports.rejectValueThatLooksLikeFlag = rejectValueThatLooksLikeFlag;
+class CliArgsError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'CliArgsError';
+    }
+}
+exports.CliArgsError = CliArgsError;
+function getStringOption(args, name, fallback) {
+    const index = args.indexOf(name);
+    if (index < 0)
+        return fallback;
+    const value = args[index + 1];
+    rejectMissingValue(name, value);
+    rejectValueThatLooksLikeFlag(name, value);
+    return value;
+}
+function getRequiredStringOption(args, name) {
+    const value = getStringOption(args, name);
+    if (value === undefined) {
+        throw new CliArgsError('CLI_OPTION_REQUIRED', `${name} is required`);
+    }
+    return value;
+}
+function getIntegerOption(args, name, bounds = {}) {
+    const fallback = bounds.fallback === undefined ? undefined : String(bounds.fallback);
+    const value = getStringOption(args, name, fallback);
+    if (value === undefined)
+        return undefined;
+    if (!/^\d+$/.test(value)) {
+        throw new CliArgsError('CLI_OPTION_INTEGER_INVALID', integerMessage(name, bounds));
+    }
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed) || (bounds.min !== undefined && parsed < bounds.min) || (bounds.max !== undefined && parsed > bounds.max)) {
+        throw new CliArgsError('CLI_OPTION_INTEGER_INVALID', integerMessage(name, bounds));
+    }
+    return parsed;
+}
+function getFlag(args, name) {
+    return args.includes(name);
+}
+function rejectMissingValue(name, value) {
+    if (value === undefined) {
+        throw new CliArgsError('CLI_OPTION_MISSING_VALUE', `${name} requires a value`);
+    }
+}
+function rejectValueThatLooksLikeFlag(name, value) {
+    if (value.startsWith('--')) {
+        throw new CliArgsError('CLI_OPTION_VALUE_LOOKS_LIKE_FLAG', `${name} value must not look like a flag`);
+    }
+}
+function integerMessage(name, bounds) {
+    if (bounds.min !== undefined && bounds.max !== undefined)
+        return `${name} must be an integer from ${bounds.min} to ${bounds.max}`;
+    if (bounds.min !== undefined)
+        return `${name} must be an integer greater than or equal to ${bounds.min}`;
+    if (bounds.max !== undefined)
+        return `${name} must be an integer less than or equal to ${bounds.max}`;
+    return `${name} must be an integer`;
+}

package/dist/cli/dashboard.js

@@ -0,0 +1,185 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleDashboardCommand = handleDashboardCommand;
+exports.serveDashboard = serveDashboard;
+exports.createDashboardStaticResponse = createDashboardStaticResponse;
+exports.createDashboardServerResponse = createDashboardServerResponse;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_http_1 = __importDefault(require("node:http"));
+const node_path_1 = __importDefault(require("node:path"));
+const active_run_state_1 = require("../services/active-run-state");
+const evidence_list_1 = require("../services/evidence-list");
+const operational_debt_1 = require("../services/operational-debt");
+const operations_status_service_1 = require("../services/operations-status-service");
+const task_read_model_1 = require("../services/task-read-model");
+const args_1 = require("./args");
+const DASHBOARD_HTML = node_path_1.default.join('docs', 'design', 'dashboard', 'index.html');
+const DASHBOARD_FIXTURE = node_path_1.default.join('docs', 'design', 'fixtures', 'hadara.ops.status.sample.json');
+function handleDashboardCommand(input) {
+    if (input.args[0] !== 'dashboard' || input.args[1] !== 'serve')
+        return false;
+    const host = (0, args_1.getStringOption)(input.args, '--host', '127.0.0.1');
+    const port = (0, args_1.getIntegerOption)(input.args, '--port', { fallback: 4173, min: 1, max: 65535 });
+    serveDashboard(input.projectRoot, { host, port });
+    return true;
+}
+function serveDashboard(projectRoot, options = {}) {
+    const host = options.host ?? '127.0.0.1';
+    const port = options.port ?? 4173;
+    const server = node_http_1.default.createServer((request, response) => {
+        let staticResponse;
+        try {
+            staticResponse = createDashboardServerResponse(projectRoot, request.url ?? '/', request.method ?? 'GET');
+        }
+        catch {
+            staticResponse = internalError();
+        }
+        response.writeHead(staticResponse.statusCode, staticResponse.headers);
+        response.end(staticResponse.body);
+    });
+    server.listen(port, host, () => {
+        const address = server.address();
+        const actualPort = typeof address === 'object' && address ? address.port : port;
+        // console.log(`[HADARA] Dashboard serving sample fixture at http://${host}:${actualPort}/dashboard/`);
+        console.log(`[HADARA] Dashboard serving at http://${host}:${actualPort}/dashboard/ with read-only APIs under /api/.`);
+    });
+    return server;
+}
+function createDashboardStaticResponse(projectRoot, requestUrl, method = 'GET') {
+    const normalizedMethod = method.toUpperCase();
+    if (normalizedMethod !== 'GET' && normalizedMethod !== 'HEAD')
+        return methodNotAllowed();
+    const pathname = safePathname(requestUrl);
+    if (!pathname)
+        return notFound();
+    const headOnly = normalizedMethod === 'HEAD';
+    if (pathname === '/' || pathname === '/dashboard' || pathname === '/dashboard/' || pathname === '/dashboard/index.html') {
+        return fileResponse(projectRoot, DASHBOARD_HTML, 'text/html; charset=utf-8', headOnly);
+    }
+    if (pathname === '/fixtures/hadara.ops.status.sample.json' || pathname === '/dashboard/fixtures/hadara.ops.status.sample.json') {
+        return fileResponse(projectRoot, DASHBOARD_FIXTURE, 'application/json; charset=utf-8', headOnly);
+    }
+    return notFound();
+}
+function createDashboardServerResponse(projectRoot, requestUrl, method = 'GET') {
+    try {
+        const apiResponse = createDashboardApiResponse(projectRoot, requestUrl, method);
+        if (apiResponse)
+            return apiResponse;
+        return createDashboardStaticResponse(projectRoot, requestUrl, method);
+    }
+    catch {
+        return internalError();
+    }
+}
+function createDashboardApiResponse(projectRoot, requestUrl, method) {
+    const normalizedMethod = method.toUpperCase();
+    if (normalizedMethod !== 'GET' && normalizedMethod !== 'HEAD')
+        return null;
+    const url = safeUrl(requestUrl);
+    if (!url || !url.pathname.startsWith('/api/'))
+        return null;
+    const headOnly = normalizedMethod === 'HEAD';
+    if (url.pathname === '/api/status')
+        return jsonResponse((0, operations_status_service_1.createOpsStatusReport)(projectRoot), headOnly);
+    if (url.pathname === '/api/tasks')
+        return jsonResponse((0, task_read_model_1.createTaskListReport)(projectRoot), headOnly);
+    if (url.pathname === '/api/active-run')
+        return jsonResponse((0, active_run_state_1.safeCreateActiveRunProjection)(projectRoot), headOnly);
+    if (url.pathname === '/api/debt')
+        return jsonResponse((0, operational_debt_1.createOperationalDebtReport)(projectRoot), headOnly);
+    if (url.pathname === '/api/evidence') {
+        const taskId = url.searchParams.get('taskId')?.trim();
+        if (!taskId) {
+            return jsonResponse({
+                schemaVersion: 'hadara.dashboard.api.error.v1',
+                command: 'dashboard.api',
+                ok: false,
+                issues: [
+                    {
+                        severity: 'error',
+                        code: 'TASK_ID_REQUIRED',
+                        message: 'Missing required query parameter: taskId.'
+                    }
+                ]
+            }, headOnly, 400);
+        }
+        return jsonResponse((0, evidence_list_1.createEvidenceListReport)(projectRoot, { taskId }), headOnly);
+    }
+    return notFound();
+}
+function safePathname(requestUrl) {
+    const url = safeUrl(requestUrl);
+    return url?.pathname ?? null;
+}
+function safeUrl(requestUrl) {
+    if (/(^|\/)\.\.?($|[/?#])|%2e|%2f|\\/i.test(requestUrl))
+        return null;
+    try {
+        return new URL(requestUrl, 'http://hadara.local');
+    }
+    catch {
+        return null;
+    }
+}
+function fileResponse(projectRoot, relativePath, contentType, headOnly) {
+    const filePath = node_path_1.default.join(projectRoot, relativePath);
+    if (!node_fs_1.default.existsSync(filePath))
+        return notFound();
+    const body = node_fs_1.default.readFileSync(filePath, 'utf8');
+    return {
+        statusCode: 200,
+        headers: securityHeaders({
+            'content-type': contentType,
+            'content-length': String(Buffer.byteLength(body))
+        }),
+        body: headOnly ? '' : body
+    };
+}
+function jsonResponse(bodyValue, headOnly, statusCode = 200) {
+    const body = `${JSON.stringify(bodyValue, null, 2)}\n`;
+    return {
+        statusCode,
+        headers: securityHeaders({
+            'content-type': 'application/json; charset=utf-8',
+            'content-length': String(Buffer.byteLength(body))
+        }),
+        body: headOnly ? '' : body
+    };
+}
+function notFound() {
+    return {
+        statusCode: 404,
+        headers: securityHeaders({ 'content-type': 'text/plain; charset=utf-8' }),
+        body: 'Not found'
+    };
+}
+function methodNotAllowed() {
+    return {
+        statusCode: 405,
+        headers: securityHeaders({
+            'content-type': 'text/plain; charset=utf-8',
+            allow: 'GET, HEAD'
+        }),
+        body: 'Method not allowed'
+    };
+}
+function internalError() {
+    return {
+        statusCode: 500,
+        headers: securityHeaders({ 'content-type': 'text/plain; charset=utf-8' }),
+        body: 'Internal server error'
+    };
+}
+function securityHeaders(headers) {
+    return {
+        ...headers,
+        'cache-control': 'no-store',
+        'content-security-policy': "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; connect-src 'self'; img-src 'self'; object-src 'none'; base-uri 'none'",
+        'referrer-policy': 'no-referrer',
+        'x-content-type-options': 'nosniff'
+    };
+}

package/dist/cli/debt.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleDebtCommand = handleDebtCommand;
+const operational_debt_1 = require("../services/operational-debt");
+function handleDebtCommand(input) {
+    if (input.args[0] !== 'debt')
+        return false;
+    const sub = input.args[1];
+    if (sub === 'list') {
+        const report = (0, operational_debt_1.createOperationalDebtReport)(input.projectRoot);
+        if (input.jsonOutput) {
+            console.log(JSON.stringify(report, null, 2));
+        }
+        else {
+            for (const record of report.records) {
+                console.log(`${record.id} | ${record.severity} | ${record.status} | ${record.title}`);
+            }
+        }
+        return true;
+    }
+    if (sub === 'show') {
+        const id = input.args[2];
+        if (!id)
+            throw new Error('debt show requires an id');
+        const report = (0, operational_debt_1.createOperationalDebtShowReport)(input.projectRoot, id);
+        if (input.jsonOutput) {
+            console.log(JSON.stringify(report, null, 2));
+        }
+        else if (report.record) {
+            console.log(`${report.record.id} | ${report.record.severity} | ${report.record.status} | ${report.record.title}`);
+            console.log(`targetCapability: ${report.record.targetCapability}`);
+        }
+        else {
+            console.log(`[HADARA] ${report.issues[0]?.message ?? `Operational debt record not found: ${id}`}`);
+        }
+        if (!report.ok)
+            process.exitCode = 6;
+        return true;
+    }
+    return false;
+}

package/dist/cli/doctor.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDoctorReport = createDoctorReport;
+exports.formatDoctorReport = formatDoctorReport;
+exports.handleDoctorCommand = handleDoctorCommand;
+const node_fs_1 = __importDefault(require("node:fs"));
+function createDoctorReport(paths, nodeVersion = process.version) {
+    const checks = [
+        pathCheck('docs', paths.projectDocsDir),
+        pathCheck('tasks', paths.projectTasksDir),
+        pathCheck('project-context', paths.projectHadaraDir)
+    ];
+    return {
+        schemaVersion: 'hadara.doctor.v1',
+        command: 'doctor',
+        ok: checks.every((check) => check.status === 'ok'),
+        runtime: {
+            node: nodeVersion
+        },
+        paths: {
+            portableRoot: paths.portableRoot,
+            dataRoot: paths.dataRoot,
+            projectRoot: paths.projectRoot
+        },
+        checks
+    };
+}
+function formatDoctorReport(report) {
+    return [
+        '[HADARA] Doctor',
+        `portableRoot: ${report.paths.portableRoot}`,
+        `dataRoot:     ${report.paths.dataRoot}`,
+        `projectRoot:  ${report.paths.projectRoot}`,
+        `Node:         ${report.runtime.node}`,
+        ...report.checks.map((check) => `${formatCheckLabel(check.id)}${check.status}`)
+    ].join('\n');
+}
+function handleDoctorCommand(input) {
+    const report = createDoctorReport(input.paths);
+    if (input.jsonOutput) {
+        console.log(JSON.stringify(report, null, 2));
+    }
+    else {
+        console.log(formatDoctorReport(report));
+    }
+    if (!report.ok)
+        process.exitCode = 7;
+    return true;
+}
+function pathCheck(id, targetPath) {
+    return {
+        id,
+        status: node_fs_1.default.existsSync(targetPath) ? 'ok' : 'missing',
+        path: targetPath
+    };
+}
+function formatCheckLabel(id) {
+    if (id === 'docs')
+        return 'docs/:       ';
+    if (id === 'tasks')
+        return 'tasks/:      ';
+    if (id === 'project-context')
+        return '.hadara/:    ';
+    return `${id}: `;
+}