@open-agent-toolkit/cli 0.1.72 → 0.1.73

package/dist/commands/init/tools/shared/skill-manifest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"skill-manifest.d.ts","sourceRoot":"","sources":["../../../../../src/commands/init/tools/shared/skill-manifest.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAgBH,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;CAClC;AAED,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAKtD,CAAC;AAEF,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAE5E;AAID,eAAO,MAAM,eAAe,s3BAmClB,CAAC;AAEX,eAAO,MAAM,eAAe,oFAIlB,CAAC;AAEX,eAAO,MAAM,kBAAkB,6GAQrB,CAAC;AAEX,eAAO,MAAM,gBAAgB,qFAInB,CAAC;AAIX,eAAO,MAAM,WAAW,2FAKd,CAAC;AAIX,eAAO,MAAM,WAAW,qCAAsC,CAAC;AAI/D,eAAO,MAAM,WAAW,iLAQd,CAAC;AAEX,eAAO,MAAM,YAAY,kCAAmC,CAAC;AAI7D,eAAO,MAAM,cAAc,2NASjB,CAAC;AAIX,eAAO,MAAM,yBAAyB,sHAK5B,CAAC;AAEX,eAAO,MAAM,4BAA4B,yIAQ/B,CAAC;AAEX,eAAO,MAAM,0BAA0B,aAAc,CAAC;AAItD,eAAO,MAAM,iBAAiB,6BAA8B,CAAC;AAI7D,eAAO,MAAM,eAAe,2EAMlB,CAAC;AAEX,eAAO,MAAM,eAAe,qCAAsC,CAAC"}
+{"version":3,"file":"skill-manifest.d.ts","sourceRoot":"","sources":["../../../../../src/commands/init/tools/shared/skill-manifest.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAgBH,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;CAClC;AAED,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAKtD,CAAC;AAEF,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAE5E;AAID,eAAO,MAAM,eAAe,s3BAmClB,CAAC;AAEX,eAAO,MAAM,eAAe,oFAIlB,CAAC;AAEX,eAAO,MAAM,kBAAkB,+HASrB,CAAC;AAEX,eAAO,MAAM,gBAAgB,qFAInB,CAAC;AAIX,eAAO,MAAM,WAAW,2FAKd,CAAC;AAIX,eAAO,MAAM,WAAW,qCAAsC,CAAC;AAI/D,eAAO,MAAM,WAAW,iLAQd,CAAC;AAEX,eAAO,MAAM,YAAY,kCAAmC,CAAC;AAI7D,eAAO,MAAM,cAAc,2NASjB,CAAC;AAIX,eAAO,MAAM,yBAAyB,sHAK5B,CAAC;AAEX,eAAO,MAAM,4BAA4B,yIAQ/B,CAAC;AAEX,eAAO,MAAM,0BAA0B,aAAc,CAAC;AAItD,eAAO,MAAM,iBAAiB,6BAA8B,CAAC;AAI7D,eAAO,MAAM,eAAe,2EAMlB,CAAC;AAEX,eAAO,MAAM,eAAe,qCAAsC,CAAC"}

package/dist/commands/init/tools/shared/skill-manifest.js

@@ -64,6 +64,7 @@ export const WORKFLOW_TEMPLATES = [
     'plan.md',
     'implementation.md',
     'summary.md',
+    'project-log.md',
 ];
 export const WORKFLOW_SCRIPTS = [
     'generate-oat-state.sh',

package/dist/commands/project/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/project/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAepC,wBAAgB,oBAAoB,IAAI,OAAO,CAe9C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/project/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAgBpC,wBAAgB,oBAAoB,IAAI,OAAO,CAgB9C"}

package/dist/commands/project/index.js

@@ -4,6 +4,7 @@ import { createProjectCompleteDiscoveryCommand } from './complete-discovery/inde
 import { createProjectCompleteStateCommand } from './complete-state/index.js';
 import { createProjectDispatchCeilingCommand } from './dispatch-ceiling/index.js';
 import { createProjectListCommand } from './list.js';
+import { createProjectLogCommand } from './log/index.js';
 import { createProjectNewCommand } from './new/index.js';
 import { createProjectOpenCommand } from './open/index.js';
 import { createProjectPauseCommand } from './pause/index.js';
@@ -19,6 +20,7 @@ export function createProjectCommand() {
         .addCommand(createProjectCompleteStateCommand())
         .addCommand(createProjectDispatchCeilingCommand())
         .addCommand(createProjectListCommand())
+        .addCommand(createProjectLogCommand())
         .addCommand(createProjectNewCommand())
         .addCommand(createProjectOpenCommand())
         .addCommand(createProjectPauseCommand())

package/dist/commands/project/log/append.d.ts

@@ -0,0 +1,41 @@
+import { type CommandContext, type GlobalOptions } from '../../../app/command-context.js';
+import { type ActiveProjectResolution } from '../../../config/oat-config.js';
+import { type ResolvedConfig } from '../../../config/resolve.js';
+import { Command } from 'commander';
+export interface AppendProjectLogInput {
+    repoRoot: string;
+    home?: string;
+    project?: string;
+    structural?: boolean;
+    type?: string;
+    scope?: string;
+    area?: string;
+    producer?: string;
+    ref?: string;
+    body?: string;
+    versionNote?: string;
+}
+export type ProjectLogAppendResult = {
+    status: 'appended';
+    logPath: string;
+    heading: string;
+    created: boolean;
+} | {
+    status: 'skipped';
+    reason: 'projectLog=false';
+};
+export interface AppendProjectLogDependencies {
+    resolveActiveProject: (repoRoot: string) => Promise<ActiveProjectResolution>;
+    resolveEffectiveConfig: (repoRoot: string, userConfigDir: string, env?: NodeJS.ProcessEnv) => Promise<ResolvedConfig>;
+    resolveAssetsRoot: () => Promise<string>;
+    now: () => Date;
+}
+export interface ProjectLogAppendCommandDependencies extends AppendProjectLogDependencies {
+    buildCommandContext: (options: GlobalOptions) => CommandContext;
+    resolveProjectRoot: (cwd: string) => Promise<string>;
+    readStdin: () => Promise<string>;
+}
+export declare function instantiateProjectLogTemplate(template: string, projectName: string, date: string): string;
+export declare function appendProjectLog(input: AppendProjectLogInput, overrides?: Partial<AppendProjectLogDependencies>): Promise<ProjectLogAppendResult>;
+export declare function createProjectLogAppendCommand(overrides?: Partial<ProjectLogAppendCommandDependencies>): Command;
+//# sourceMappingURL=append.d.ts.map

package/dist/commands/project/log/append.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"append.d.ts","sourceRoot":"","sources":["../../../../src/commands/project/log/append.ts"],"names":[],"mappings":"AAIA,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,aAAa,EACnB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAEL,KAAK,uBAAuB,EAC7B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAA0B,KAAK,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAI9E,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAkBpC,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,MAAM,sBAAsB,GAC9B;IACE,MAAM,EAAE,UAAU,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;CAClB,GACD;IACE,MAAM,EAAE,SAAS,CAAC;IAClB,MAAM,EAAE,kBAAkB,CAAC;CAC5B,CAAC;AAEN,MAAM,WAAW,4BAA4B;IAC3C,oBAAoB,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,uBAAuB,CAAC,CAAC;IAC7E,sBAAsB,EAAE,CACtB,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,MAAM,EACrB,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,KACpB,OAAO,CAAC,cAAc,CAAC,CAAC;IAC7B,iBAAiB,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IACzC,GAAG,EAAE,MAAM,IAAI,CAAC;CACjB;AAqBD,MAAM,WAAW,mCAAoC,SAAQ,4BAA4B;IACvF,mBAAmB,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,cAAc,CAAC;IAChE,kBAAkB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACrD,SAAS,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;CAClC;AA4LD,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,MAAM,GACX,MAAM,CAOR;AAiCD,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,qBAAqB,EAC5B,SAAS,GAAE,OAAO,CAAC,4BAA4B,CAAM,GACpD,OAAO,CAAC,sBAAsB,CAAC,CAoCjC;AAsCD,wBAAgB,6BAA6B,CAC3C,SAAS,GAAE,OAAO,CAAC,mCAAmC,CAAM,GAC3D,OAAO,CA8CT"}

package/dist/commands/project/log/append.js

@@ -0,0 +1,241 @@
+import { appendFile, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { basename, isAbsolute, join, resolve } from 'node:path';
+import { buildCommandContext, } from '../../../app/command-context.js';
+import { readGlobalOptions } from '../../shared/shared.utils.js';
+import { resolveActiveProject, } from '../../../config/oat-config.js';
+import { resolveEffectiveConfig } from '../../../config/resolve.js';
+import { resolveAssetsRoot } from '../../../fs/assets.js';
+import { dirExists, fileExists } from '../../../fs/io.js';
+import { resolveProjectRoot } from '../../../fs/paths.js';
+import { Command } from 'commander';
+import { composeJudgmentHeading, composeStructuralHeading, isProjectLogEntryMarker, isProjectLogSectionMarker, PROJECT_LOG_AREA_MAX_LENGTH, PROJECT_LOG_HEADING_DELIMITER, PROJECT_LOG_SCOPES, PROJECT_LOG_TYPES, } from './grammar.js';
+const PROJECT_LOG_FILENAME = 'project-log.md';
+const SYNTHESIS_HEADING_PREFIX = '\n## End-of-run synthesis';
+const DEFAULT_APPEND_DEPENDENCIES = {
+    resolveActiveProject,
+    resolveEffectiveConfig,
+    resolveAssetsRoot,
+    now: () => new Date(),
+};
+const DEFAULT_COMMAND_DEPENDENCIES = {
+    ...DEFAULT_APPEND_DEPENDENCIES,
+    buildCommandContext,
+    resolveProjectRoot,
+    readStdin: async () => {
+        const chunks = [];
+        for await (const chunk of process.stdin) {
+            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        }
+        return Buffer.concat(chunks).toString('utf8');
+    },
+};
+function validateSingleLine(value, option, maxLength = PROJECT_LOG_AREA_MAX_LENGTH) {
+    const normalized = value?.trim() ?? '';
+    if (!normalized) {
+        throw new Error(`${option} is required and must be a non-empty single line.`);
+    }
+    if (/[\r\n]/.test(value ?? '')) {
+        throw new Error(`${option} must be a single line without newline characters.`);
+    }
+    if (normalized.length > maxLength) {
+        throw new Error(`${option} must be at most ${maxLength} characters.`);
+    }
+    return normalized;
+}
+function validateHeadingField(value, option) {
+    const normalized = validateSingleLine(value, option);
+    if (normalized.includes(PROJECT_LOG_HEADING_DELIMITER)) {
+        throw new Error(`${option} must not contain the project-log heading delimiter '${PROJECT_LOG_HEADING_DELIMITER}'.`);
+    }
+    return normalized;
+}
+function validateVersionNote(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    return validateSingleLine(value, '--version-note', Number.MAX_SAFE_INTEGER);
+}
+function containsCommandOwnedMarker(body) {
+    return body
+        .split(/\r?\n/)
+        .some((line) => isProjectLogSectionMarker(line) || isProjectLogEntryMarker(line));
+}
+function validateEntry(input, date) {
+    const body = input.body?.trim();
+    if (!body) {
+        throw new Error('--body is required and must contain non-whitespace text.');
+    }
+    const versionNote = validateVersionNote(input.versionNote);
+    if (input.structural) {
+        if (input.type !== undefined ||
+            input.scope !== undefined ||
+            input.area !== undefined) {
+            throw new Error('--structural cannot be combined with judgment flags --type, --scope, or --area.');
+        }
+        if (/[\r\n]/.test(body)) {
+            throw new Error('--body for structural entries must be one line without newline characters.');
+        }
+        if (containsCommandOwnedMarker(body)) {
+            throw new Error('--body for structural entries must not contain command-owned level-two or level-three Markdown headings.');
+        }
+        const producer = validateHeadingField(input.producer, '--producer');
+        const ref = validateHeadingField(input.ref, '--ref');
+        return {
+            heading: composeStructuralHeading({ date, producer, ref }),
+            body,
+            versionNote,
+        };
+    }
+    if (input.producer !== undefined || input.ref !== undefined) {
+        throw new Error('Judgment entries cannot use structural flags --producer or --ref; add --structural or remove those flags.');
+    }
+    if (!input.type) {
+        throw new Error(`--type is required for judgment entries; accepted values: ${PROJECT_LOG_TYPES.join(' | ')}.`);
+    }
+    if (!PROJECT_LOG_TYPES.includes(input.type)) {
+        throw new Error(`Invalid --type '${input.type}'; accepted values: ${PROJECT_LOG_TYPES.join(' | ')}.`);
+    }
+    if (!input.scope) {
+        throw new Error(`--scope is required for judgment entries; accepted values: ${PROJECT_LOG_SCOPES.join(' | ')}.`);
+    }
+    if (!PROJECT_LOG_SCOPES.includes(input.scope)) {
+        throw new Error(`Invalid --scope '${input.scope}'; accepted values: ${PROJECT_LOG_SCOPES.join(' | ')}.`);
+    }
+    if (containsCommandOwnedMarker(body)) {
+        throw new Error('--body for judgment entries must not contain command-owned level-two or level-three Markdown headings.');
+    }
+    const area = validateHeadingField(input.area, '--area');
+    return {
+        heading: composeJudgmentHeading({
+            date,
+            type: input.type,
+            scope: input.scope,
+            area,
+        }),
+        body,
+        versionNote,
+    };
+}
+async function resolveTargetProject(input, dependencies) {
+    if (input.project) {
+        const projectPath = isAbsolute(input.project)
+            ? resolve(input.project)
+            : resolve(input.repoRoot, input.project);
+        if (!(await dirExists(projectPath)) ||
+            !(await fileExists(join(projectPath, 'state.md')))) {
+            throw new Error(`Project path is missing or invalid: ${input.project}. Pass --project <path> for a directory containing state.md.`);
+        }
+        return projectPath;
+    }
+    const active = await dependencies.resolveActiveProject(input.repoRoot);
+    if (active.status !== 'active' || !active.path) {
+        throw new Error('No active project resolves. Set activeProject or pass --project <path>.');
+    }
+    return resolve(input.repoRoot, active.path);
+}
+export function instantiateProjectLogTemplate(template, projectName, date) {
+    const instantiated = template
+        .replaceAll('{Project Name}', projectName)
+        .replaceAll('YYYY-MM-DD', date)
+        .replaceAll(/\n?oat_template:\s*true\s*\n/gi, '\n')
+        .replaceAll(/\n?oat_template_name:\s*[^\n]*\n/gi, '\n');
+    return instantiated.endsWith('\n') ? instantiated : `${instantiated}\n`;
+}
+async function appendEntry(logPath, heading, body, versionNote) {
+    const bodyWithVersion = versionNote?.trim()
+        ? `${body} (observed on ${versionNote.trim()})`
+        : body;
+    const entry = `\n${heading}\n\n${bodyWithVersion}\n`;
+    const content = await readFile(logPath, 'utf8');
+    const synthesisIndex = content.indexOf(SYNTHESIS_HEADING_PREFIX);
+    if (synthesisIndex >= 0) {
+        await writeFile(logPath, `${content.slice(0, synthesisIndex)}${entry}${content.slice(synthesisIndex)}`, 'utf8');
+        return;
+    }
+    await appendFile(logPath, `${content.endsWith('\n') ? '' : '\n'}${entry}`, 'utf8');
+}
+export async function appendProjectLog(input, overrides = {}) {
+    const dependencies = { ...DEFAULT_APPEND_DEPENDENCIES, ...overrides };
+    const projectPath = await resolveTargetProject(input, dependencies);
+    const logPath = join(projectPath, PROJECT_LOG_FILENAME);
+    const logExists = await fileExists(logPath);
+    if (!logExists) {
+        const effective = await dependencies.resolveEffectiveConfig(input.repoRoot, join(input.home ?? homedir(), '.oat'));
+        if (effective.resolved['workflow.projectLog']?.value === false) {
+            return { status: 'skipped', reason: 'projectLog=false' };
+        }
+    }
+    const date = dependencies.now().toISOString().slice(0, 10);
+    const { heading, body, versionNote } = validateEntry(input, date);
+    let created = false;
+    if (!logExists) {
+        const assetsRoot = await dependencies.resolveAssetsRoot();
+        const template = await readFile(join(assetsRoot, 'templates', PROJECT_LOG_FILENAME), 'utf8');
+        await writeFile(logPath, instantiateProjectLogTemplate(template, basename(projectPath), date), 'utf8');
+        created = true;
+    }
+    await appendEntry(logPath, heading, body, versionNote);
+    return { status: 'appended', logPath, heading, created };
+}
+async function runAppendCommand(options, context, dependencies) {
+    try {
+        const repoRoot = await dependencies.resolveProjectRoot(context.cwd);
+        const body = options.body === '-' ? await dependencies.readStdin() : options.body;
+        const result = await appendProjectLog({
+            repoRoot,
+            home: context.home,
+            ...options,
+            body,
+        }, dependencies);
+        if (context.json) {
+            context.logger.json(result);
+        }
+        else if (result.status === 'appended') {
+            context.logger.success(`Appended project log entry: ${result.logPath}`);
+        }
+        process.exitCode = 0;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (context.json) {
+            context.logger.json({ status: 'error', message });
+        }
+        else {
+            context.logger.error(message);
+        }
+        process.exitCode = 1;
+    }
+}
+export function createProjectLogAppendCommand(overrides = {}) {
+    const dependencies = { ...DEFAULT_COMMAND_DEPENDENCIES, ...overrides };
+    return new Command('append')
+        .description('Append a validated entry to the active project log')
+        .option('--structural', 'Write a structural lifecycle entry')
+        .option('--type <type>', 'Judgment type: bug, friction, worked-well, feedback')
+        .option('--scope <scope>', 'Judgment scope: project or general')
+        .option('--area <area>', 'Short single-line judgment area (maximum 120 characters)')
+        .option('--producer <producer>', 'Structural producer skill or command')
+        .option('--ref <ref>', 'Structural phase, scope, or artifact reference')
+        .option('--body <text>', 'Entry body, or - to read the body from stdin')
+        .option('--version-note <text>', 'Append an observed-on version clause')
+        .option('--project <path>', 'Explicit project path; defaults to the active project')
+        .addHelpText('after', `
+Entry contract:
+  Log breaks, surprises, workarounds, or notable successes; record evidence, not narrative.
+  worked-well entries are do-not-regress evidence. Judgment bodies should use 1–3 sentences.
+  High-value judgments may use Observation:, Impact:, and Recommendation: fields.
+  Structural bodies are one line and reference artifacts by path instead of inlining them.
+  Add --version-note for tool-related observations.
+  Never record secret values (tokens, keys, signed URLs, or credentials); reference secrets by name or source.
+  Prior entries are never edited or struck through. Append a new judgment entry that references and explains a correction.
+
+Heading grammars:
+  ### YYYY-MM-DD · <project|general> · <bug|friction|worked-well|feedback> · <area>
+  ### YYYY-MM-DD · structural · <producer> · <ref>
+`)
+        .action(async (options, command) => {
+        const context = dependencies.buildCommandContext(readGlobalOptions(command));
+        await runAppendCommand(options, context, dependencies);
+    });
+}

package/dist/commands/project/log/check.d.ts

@@ -0,0 +1,66 @@
+import { type CommandContext, type GlobalOptions } from '../../../app/command-context.js';
+import { type ActiveProjectResolution } from '../../../config/oat-config.js';
+import { Command } from 'commander';
+import { type ProjectLogSection, type ProjectLogScope, type ProjectLogType } from './grammar.js';
+export declare const PROJECT_LOG_FILENAME = "project-log.md";
+export declare const SYNTHESIS_PENDING_HEADING = "## End-of-run synthesis (pending \u2014 do not skip at project completion)";
+export declare const SYNTHESIS_COMPLETE_HEADING = "## End-of-run synthesis";
+export interface ProjectLogCheckResult {
+    status: 'ok' | 'absent' | 'synthesis_pending';
+    logPath: string | null;
+    entryCounts: {
+        structural: number;
+        judgment: Record<ProjectLogType, number>;
+    };
+    scopeCounts: Record<ProjectLogScope, number>;
+    lastEntryDate: string | null;
+    synthesisPending: boolean;
+    grammarViolations: string[];
+}
+export type ParsedProjectLogEntry = {
+    class: 'judgment';
+    heading: string;
+    date: string;
+    scope: ProjectLogScope;
+    type: ProjectLogType;
+    area: string;
+    body: string;
+} | {
+    class: 'structural';
+    heading: string;
+    date: string;
+    producer: string;
+    ref: string;
+    body: string;
+};
+export interface ParsedProjectLog {
+    entries: ParsedProjectLogEntry[];
+    grammarViolations: string[];
+}
+export type ProjectLogSynthesisSection = {
+    status: 'pending';
+    section: ProjectLogSection;
+} | {
+    status: 'complete';
+    section: ProjectLogSection;
+} | {
+    status: 'missing';
+} | {
+    status: 'ambiguous';
+};
+export interface CheckProjectLogInput {
+    repoRoot: string;
+    project?: string;
+}
+export interface CheckProjectLogDependencies {
+    resolveActiveProject: (repoRoot: string) => Promise<ActiveProjectResolution>;
+}
+export interface ProjectLogCheckCommandDependencies extends CheckProjectLogDependencies {
+    buildCommandContext: (options: GlobalOptions) => CommandContext;
+    resolveProjectRoot: (cwd: string) => Promise<string>;
+}
+export declare function findCanonicalProjectLogSynthesisSection(content: string): ProjectLogSynthesisSection;
+export declare function parseProjectLogEntries(content: string): ParsedProjectLog;
+export declare function checkProjectLog(input: CheckProjectLogInput, overrides?: Partial<CheckProjectLogDependencies>): Promise<ProjectLogCheckResult>;
+export declare function createProjectLogCheckCommand(overrides?: Partial<ProjectLogCheckCommandDependencies>): Command;
+//# sourceMappingURL=check.d.ts.map

package/dist/commands/project/log/check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../../../src/commands/project/log/check.ts"],"names":[],"mappings":"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"}

package/dist/commands/project/log/check.js

@@ -0,0 +1,194 @@
+import { readFile } from 'node:fs/promises';
+import { isAbsolute, join, resolve } from 'node:path';
+import { buildCommandContext, } from '../../../app/command-context.js';
+import { readGlobalOptions } from '../../shared/shared.utils.js';
+import { resolveActiveProject, } from '../../../config/oat-config.js';
+import { dirExists, fileExists } from '../../../fs/io.js';
+import { resolveProjectRoot } from '../../../fs/paths.js';
+import { Command } from 'commander';
+import { findProjectLogSections, isProjectLogEntryMarker, JUDGMENT_HEADING_RE, PROJECT_LOG_TYPES, STRUCTURAL_HEADING_RE, } from './grammar.js';
+export const PROJECT_LOG_FILENAME = 'project-log.md';
+export const SYNTHESIS_PENDING_HEADING = '## End-of-run synthesis (pending — do not skip at project completion)';
+export const SYNTHESIS_COMPLETE_HEADING = '## End-of-run synthesis';
+const DEFAULT_CHECK_DEPENDENCIES = {
+    resolveActiveProject,
+};
+const DEFAULT_COMMAND_DEPENDENCIES = {
+    ...DEFAULT_CHECK_DEPENDENCIES,
+    buildCommandContext,
+    resolveProjectRoot,
+};
+function emptyCounts() {
+    return {
+        entryCounts: {
+            structural: 0,
+            judgment: {
+                bug: 0,
+                friction: 0,
+                'worked-well': 0,
+                feedback: 0,
+            },
+        },
+        scopeCounts: { project: 0, general: 0 },
+    };
+}
+function entriesSection(content) {
+    const section = findProjectLogSections(content).find(({ heading }) => heading === '## Entries');
+    if (!section) {
+        return '';
+    }
+    return content.slice(section.start + section.heading.length, section.end);
+}
+export function findCanonicalProjectLogSynthesisSection(content) {
+    const candidates = findProjectLogSections(content).filter(({ heading }) => heading === SYNTHESIS_PENDING_HEADING ||
+        heading === SYNTHESIS_COMPLETE_HEADING);
+    if (candidates.length === 0) {
+        return { status: 'missing' };
+    }
+    if (candidates.length !== 1) {
+        return { status: 'ambiguous' };
+    }
+    const section = candidates[0];
+    return {
+        status: section.heading === SYNTHESIS_PENDING_HEADING ? 'pending' : 'complete',
+        section,
+    };
+}
+export function parseProjectLogEntries(content) {
+    const lines = entriesSection(content).split('\n');
+    const entries = [];
+    const grammarViolations = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const heading = lines[index];
+        if (!heading || !isProjectLogEntryMarker(heading)) {
+            continue;
+        }
+        const bodyLines = [];
+        let cursor = index + 1;
+        while (cursor < lines.length &&
+            !isProjectLogEntryMarker(lines[cursor] ?? '')) {
+            bodyLines.push(lines[cursor] ?? '');
+            cursor += 1;
+        }
+        const body = bodyLines.join('\n').trim();
+        index = cursor - 1;
+        const judgment = JUDGMENT_HEADING_RE.exec(heading);
+        if (judgment) {
+            entries.push({
+                class: 'judgment',
+                heading,
+                date: judgment[1],
+                scope: judgment[2],
+                type: judgment[3],
+                area: judgment[4].trim(),
+                body,
+            });
+            continue;
+        }
+        const structural = STRUCTURAL_HEADING_RE.exec(heading);
+        if (structural) {
+            entries.push({
+                class: 'structural',
+                heading,
+                date: structural[1],
+                producer: structural[2].trim(),
+                ref: structural[3].trim(),
+                body,
+            });
+            continue;
+        }
+        grammarViolations.push(heading);
+    }
+    return { entries, grammarViolations };
+}
+async function resolveTargetProject(input, dependencies) {
+    if (input.project) {
+        const projectPath = isAbsolute(input.project)
+            ? resolve(input.project)
+            : resolve(input.repoRoot, input.project);
+        if (!(await dirExists(projectPath)) ||
+            !(await fileExists(join(projectPath, 'state.md')))) {
+            throw new Error(`Project path is missing or invalid: ${input.project}. Pass --project <path> for a directory containing state.md.`);
+        }
+        return projectPath;
+    }
+    const active = await dependencies.resolveActiveProject(input.repoRoot);
+    if (active.status !== 'active' || !active.path) {
+        throw new Error('No active project resolves. Set activeProject or pass --project <path>.');
+    }
+    return resolve(input.repoRoot, active.path);
+}
+export async function checkProjectLog(input, overrides = {}) {
+    const dependencies = { ...DEFAULT_CHECK_DEPENDENCIES, ...overrides };
+    const projectPath = await resolveTargetProject(input, dependencies);
+    const logPath = join(projectPath, PROJECT_LOG_FILENAME);
+    if (!(await fileExists(logPath))) {
+        return {
+            status: 'absent',
+            logPath: null,
+            ...emptyCounts(),
+            lastEntryDate: null,
+            synthesisPending: false,
+            grammarViolations: [],
+        };
+    }
+    const content = await readFile(logPath, 'utf8');
+    const parsed = parseProjectLogEntries(content);
+    const counts = emptyCounts();
+    for (const entry of parsed.entries) {
+        if (entry.class === 'structural') {
+            counts.entryCounts.structural += 1;
+        }
+        else {
+            counts.entryCounts.judgment[entry.type] += 1;
+            counts.scopeCounts[entry.scope] += 1;
+        }
+    }
+    const synthesisPending = findProjectLogSections(content).some(({ heading }) => heading === SYNTHESIS_PENDING_HEADING);
+    return {
+        status: synthesisPending ? 'synthesis_pending' : 'ok',
+        logPath,
+        ...counts,
+        lastEntryDate: parsed.entries.at(-1)?.date ?? null,
+        synthesisPending,
+        grammarViolations: parsed.grammarViolations,
+    };
+}
+async function runCheckCommand(options, context, dependencies) {
+    try {
+        const repoRoot = await dependencies.resolveProjectRoot(context.cwd);
+        const result = await checkProjectLog({ repoRoot, project: options.project }, dependencies);
+        if (context.json) {
+            context.logger.json(result);
+        }
+        else {
+            context.logger.info(result.status === 'absent'
+                ? 'Project log: absent'
+                : `Project log: ${result.status}; entries: ${result.entryCounts.structural +
+                    PROJECT_LOG_TYPES.reduce((total, type) => total + result.entryCounts.judgment[type], 0)}`);
+        }
+        process.exitCode =
+            options.requireSynthesis && result.synthesisPending ? 1 : 0;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (context.json) {
+            context.logger.json({ status: 'error', message });
+        }
+        else {
+            context.logger.error(message);
+        }
+        process.exitCode = 1;
+    }
+}
+export function createProjectLogCheckCommand(overrides = {}) {
+    const dependencies = { ...DEFAULT_COMMAND_DEPENDENCIES, ...overrides };
+    return new Command('check')
+        .description('Inspect project-log entries and synthesis status')
+        .option('--project <path>', 'Explicit project path; defaults to the active project')
+        .option('--require-synthesis', 'Exit 1 when the project log still has pending synthesis')
+        .action(async (options, command) => {
+        const context = dependencies.buildCommandContext(readGlobalOptions(command));
+        await runCheckCommand(options, context, dependencies);
+    });
+}

package/dist/commands/project/log/grammar.d.ts

@@ -0,0 +1,28 @@
+export declare const PROJECT_LOG_TYPES: readonly ["bug", "friction", "worked-well", "feedback"];
+export declare const PROJECT_LOG_SCOPES: readonly ["project", "general"];
+export type ProjectLogType = (typeof PROJECT_LOG_TYPES)[number];
+export type ProjectLogScope = (typeof PROJECT_LOG_SCOPES)[number];
+export declare const PROJECT_LOG_AREA_MAX_LENGTH = 120;
+export declare const PROJECT_LOG_HEADING_DELIMITER = "\u00B7";
+export declare const JUDGMENT_HEADING_RE: RegExp;
+export declare const STRUCTURAL_HEADING_RE: RegExp;
+export interface ProjectLogSection {
+    heading: string;
+    start: number;
+    end: number;
+}
+export declare function isProjectLogSectionMarker(line: string): boolean;
+export declare function isProjectLogEntryMarker(line: string): boolean;
+export declare function findProjectLogSections(content: string): ProjectLogSection[];
+export declare function composeJudgmentHeading(input: {
+    date: string;
+    scope: ProjectLogScope;
+    type: ProjectLogType;
+    area: string;
+}): string;
+export declare function composeStructuralHeading(input: {
+    date: string;
+    producer: string;
+    ref: string;
+}): string;
+//# sourceMappingURL=grammar.d.ts.map

package/dist/commands/project/log/grammar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grammar.d.ts","sourceRoot":"","sources":["../../../../src/commands/project/log/grammar.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iBAAiB,yDAKpB,CAAC;AACX,eAAO,MAAM,kBAAkB,iCAAkC,CAAC;AAElE,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAC;AAChE,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,CAAC,CAAC;AAElE,eAAO,MAAM,2BAA2B,MAAM,CAAC;AAC/C,eAAO,MAAM,6BAA6B,WAAM,CAAC;AAEjD,eAAO,MAAM,mBAAmB,QACqE,CAAC;AACtG,eAAO,MAAM,qBAAqB,QACoC,CAAC;AAEvE,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE/D;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE7D;AAED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,iBAAiB,EAAE,CAO3E;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE;IAC5C,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,eAAe,CAAC;IACvB,IAAI,EAAE,cAAc,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,MAAM,CAET;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE;IAC9C,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;CACb,GAAG,MAAM,CAET"}

package/dist/commands/project/log/grammar.js

@@ -0,0 +1,31 @@
+export const PROJECT_LOG_TYPES = [
+    'bug',
+    'friction',
+    'worked-well',
+    'feedback',
+];
+export const PROJECT_LOG_SCOPES = ['project', 'general'];
+export const PROJECT_LOG_AREA_MAX_LENGTH = 120;
+export const PROJECT_LOG_HEADING_DELIMITER = '·';
+export const JUDGMENT_HEADING_RE = /^### (\d{4}-\d{2}-\d{2}) · (project|general) · (bug|friction|worked-well|feedback) · ([^·\r\n]+)$/;
+export const STRUCTURAL_HEADING_RE = /^### (\d{4}-\d{2}-\d{2}) · structural · ([^·\r\n]+) · ([^·\r\n]+)$/;
+export function isProjectLogSectionMarker(line) {
+    return /^## .+$/.test(line);
+}
+export function isProjectLogEntryMarker(line) {
+    return /^### .+$/.test(line);
+}
+export function findProjectLogSections(content) {
+    const matches = [...content.matchAll(/^## [^\r\n]+/gm)];
+    return matches.map((match, index) => ({
+        heading: match[0],
+        start: match.index,
+        end: matches[index + 1]?.index ?? content.length,
+    }));
+}
+export function composeJudgmentHeading(input) {
+    return `### ${input.date} · ${input.scope} · ${input.type} · ${input.area}`;
+}
+export function composeStructuralHeading(input) {
+    return `### ${input.date} · structural · ${input.producer} · ${input.ref}`;
+}