@pellux/goodvibes-sdk 0.26.11 → 0.27.0

package/dist/_internal/platform/knowledge/project-planning/helpers.js

@@ -0,0 +1,65 @@
+import { createHash } from 'node:crypto';
+import { basename, resolve } from 'node:path';
+import { PROJECT_KNOWLEDGE_SPACE_PREFIX, isProjectKnowledgeSpace, normalizeKnowledgeSpaceId, normalizeProjectId, normalizeSpaceComponent, projectKnowledgeSpaceId, } from '../spaces.js';
+export const PROJECT_PLANNING_CONNECTOR_ID = 'goodvibes-project-planning';
+export const PROJECT_PLANNING_TAG = 'project-planning';
+export function projectPlanningProjectIdFromPath(path) {
+    const resolved = resolve(path);
+    const name = normalizeSpaceComponent(basename(resolved) || 'project');
+    const digest = createHash('sha256').update(resolved).digest('hex').slice(0, 10);
+    return `${name}-${digest}`;
+}
+export function resolveProjectPlanningSpace(input = {}, defaultProjectId = 'default') {
+    const explicitSpace = typeof input.knowledgeSpaceId === 'string'
+        ? normalizeKnowledgeSpaceId(input.knowledgeSpaceId)
+        : '';
+    if (explicitSpace && isProjectKnowledgeSpace(explicitSpace)) {
+        return {
+            knowledgeSpaceId: explicitSpace,
+            projectId: projectIdFromSpace(explicitSpace),
+        };
+    }
+    const projectId = normalizeProjectId(input.projectId ?? defaultProjectId);
+    return {
+        projectId,
+        knowledgeSpaceId: projectKnowledgeSpaceId(projectId),
+    };
+}
+export function projectIdFromSpace(spaceId) {
+    const normalized = normalizeKnowledgeSpaceId(spaceId);
+    if (!normalized.startsWith(PROJECT_KNOWLEDGE_SPACE_PREFIX)) {
+        return normalizeProjectId(normalized);
+    }
+    return normalizeProjectId(normalized.slice(PROJECT_KNOWLEDGE_SPACE_PREFIX.length));
+}
+export function projectPlanningCanonicalUri(spaceId, kind, id) {
+    return `goodvibes://planning/${encodeURIComponent(spaceId)}/${kind}/${encodeURIComponent(id)}`;
+}
+export function projectPlanningSourceId(spaceId, kind, id) {
+    const digest = createHash('sha256').update(`${spaceId}:${kind}:${id}`).digest('hex').slice(0, 16);
+    return `project-planning-${kind}-${digest}`;
+}
+export function projectPlanningArtifactSummary(kind, value) {
+    if (kind === 'state') {
+        const state = value;
+        return state.goal ? `Planning state for ${state.goal}` : 'Project planning state.';
+    }
+    if (kind === 'decision') {
+        const decision = value;
+        return decision.decision ? `${decision.title ?? 'Decision'}: ${decision.decision}` : 'Project planning decision record.';
+    }
+    const language = value;
+    return `Project language artifact with ${language.terms?.length ?? 0} terms and ${language.ambiguities?.length ?? 0} resolved ambiguities.`;
+}
+export function stablePlanningId(prefix, value) {
+    const normalized = normalizeSpaceComponent(value);
+    if (normalized !== 'default')
+        return normalized;
+    const digest = createHash('sha256').update(value || prefix).digest('hex').slice(0, 10);
+    return `${prefix}-${digest}`;
+}
+export function readPlanningMetadataObject(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}

package/dist/_internal/platform/knowledge/project-planning/index.d.ts

@@ -0,0 +1,6 @@
+export { ProjectPlanningService } from './service.js';
+export type { ProjectPlanningServiceOptions } from './service.js';
+export { PROJECT_PLANNING_CONNECTOR_ID, PROJECT_PLANNING_TAG, projectPlanningCanonicalUri, projectPlanningProjectIdFromPath, projectPlanningSourceId, resolveProjectPlanningSpace, } from './helpers.js';
+export { evaluateProjectPlanningReadiness } from './readiness.js';
+export type { ProjectPlanningAgentAssignment, ProjectPlanningAmbiguity, ProjectPlanningDecision, ProjectPlanningDecisionRecordInput, ProjectPlanningDecisionResult, ProjectPlanningDecisionsResult, ProjectPlanningDecisionStatus, ProjectPlanningDependency, ProjectPlanningEvaluateInput, ProjectPlanningEvaluation, ProjectPlanningGap, ProjectPlanningGapKind, ProjectPlanningGapSeverity, ProjectPlanningGateStatus, ProjectPlanningLanguageArtifact, ProjectPlanningLanguageResult, ProjectPlanningLanguageUpsertInput, ProjectPlanningQuestion, ProjectPlanningQuestionStatus, ProjectPlanningReadiness, ProjectPlanningSpaceInput, ProjectPlanningState, ProjectPlanningStateResult, ProjectPlanningStateUpsertInput, ProjectPlanningStatus, ProjectPlanningTask, ProjectPlanningTaskStatus, ProjectPlanningTerm, ProjectPlanningVerificationGate, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/_internal/platform/knowledge/project-planning/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/knowledge/project-planning/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AACtD,YAAY,EAAE,6BAA6B,EAAE,MAAM,cAAc,CAAC;AAClE,OAAO,EACL,6BAA6B,EAC7B,oBAAoB,EACpB,2BAA2B,EAC3B,gCAAgC,EAChC,uBAAuB,EACvB,2BAA2B,GAC5B,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,gCAAgC,EAAE,MAAM,gBAAgB,CAAC;AAClE,YAAY,EACV,8BAA8B,EAC9B,wBAAwB,EACxB,uBAAuB,EACvB,kCAAkC,EAClC,6BAA6B,EAC7B,8BAA8B,EAC9B,6BAA6B,EAC7B,yBAAyB,EACzB,4BAA4B,EAC5B,yBAAyB,EACzB,kBAAkB,EAClB,sBAAsB,EACtB,0BAA0B,EAC1B,yBAAyB,EACzB,+BAA+B,EAC/B,6BAA6B,EAC7B,kCAAkC,EAClC,uBAAuB,EACvB,6BAA6B,EAC7B,wBAAwB,EACxB,yBAAyB,EACzB,oBAAoB,EACpB,0BAA0B,EAC1B,+BAA+B,EAC/B,qBAAqB,EACrB,mBAAmB,EACnB,yBAAyB,EACzB,mBAAmB,EACnB,+BAA+B,GAChC,MAAM,YAAY,CAAC"}

package/dist/_internal/platform/knowledge/project-planning/index.js

@@ -0,0 +1,3 @@
+export { ProjectPlanningService } from './service.js';
+export { PROJECT_PLANNING_CONNECTOR_ID, PROJECT_PLANNING_TAG, projectPlanningCanonicalUri, projectPlanningProjectIdFromPath, projectPlanningSourceId, resolveProjectPlanningSpace, } from './helpers.js';
+export { evaluateProjectPlanningReadiness } from './readiness.js';

package/dist/_internal/platform/knowledge/project-planning/readiness.d.ts

@@ -0,0 +1,3 @@
+import type { ProjectPlanningEvaluation, ProjectPlanningState } from './types.js';
+export declare function evaluateProjectPlanningReadiness(state: ProjectPlanningState): ProjectPlanningEvaluation;
+//# sourceMappingURL=readiness.d.ts.map

package/dist/_internal/platform/knowledge/project-planning/readiness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readiness.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/knowledge/project-planning/readiness.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,yBAAyB,EAIzB,oBAAoB,EACrB,MAAM,YAAY,CAAC;AAiBpB,wBAAgB,gCAAgC,CAAC,KAAK,EAAE,oBAAoB,GAAG,yBAAyB,CA2GvG"}

package/dist/_internal/platform/knowledge/project-planning/readiness.js

@@ -0,0 +1,124 @@
+const VAGUE_TERMS = [
+    'better',
+    'improve',
+    'improved',
+    'setup',
+    'integration',
+    'agent channel',
+    'remote',
+    'thing',
+    'stuff',
+    'etc',
+    'clean up',
+    'fix it',
+];
+export function evaluateProjectPlanningReadiness(state) {
+    const gaps = [];
+    const goal = state.goal.trim();
+    if (!goal) {
+        gaps.push(blockingQuestion('missing-goal', 'The plan needs a concrete goal before it can be executed.', 'What outcome should this plan produce?', 'A clear outcome lets the TUI inspect the right code and ask only relevant follow-up questions.', 'State the user-visible behavior or project change that should exist when the work is done.'));
+    }
+    if (!state.scope?.trim() && state.constraints.length === 0) {
+        gaps.push(blockingQuestion('missing-scope', 'The plan has no explicit boundary for what is included or excluded.', 'What is in scope, and what should be left out for this pass?', 'Scope boundaries prevent the planning loop from turning a focused change into unrelated work.', 'Define the first-pass scope and record do-later items separately.'));
+    }
+    for (const question of state.openQuestions) {
+        if ((question.status ?? 'open') === 'open') {
+            gaps.push({
+                id: `open-question:${question.id}`,
+                kind: 'open-question',
+                severity: 'blocking',
+                message: `Open planning question: ${question.prompt}`,
+                question,
+            });
+        }
+    }
+    const vagueTerm = firstVagueTerm(goal);
+    if (vagueTerm && state.answeredQuestions.length === 0 && state.decisions.length === 0) {
+        gaps.push(blockingQuestion('ambiguous-language', `The goal uses ambiguous language (${JSON.stringify(vagueTerm)}) without recorded clarification.`, `When you say ${JSON.stringify(vagueTerm)}, what concrete behavior should change?`, 'GoodVibes should challenge vague words before work starts so future agents do not implement the wrong thing.', 'Define the term in project language or replace it with concrete expected behavior.'));
+    }
+    if (goal && state.tasks.length === 0) {
+        gaps.push(blockingQuestion('missing-tasks', 'The plan has no decomposed tasks.', 'What are the smallest useful implementation tasks for this goal?', 'Task decomposition is what lets the TUI identify dependencies, parallel agent work, and verification gates.', 'Create task records with likely files, dependencies, and verification notes.'));
+    }
+    if (state.tasks.length > 1 && state.dependencies.length === 0) {
+        gaps.push({
+            id: 'missing-dependencies',
+            kind: 'missing-dependencies',
+            severity: 'advisory',
+            message: 'Multiple tasks exist but no dependency graph has been recorded.',
+        });
+    }
+    const tasksWithoutVerification = state.tasks
+        .filter((task) => (task.verification?.length ?? 0) === 0)
+        .map((task) => task.id);
+    const hasRequiredGate = state.verificationGates.some((gate) => gate.required !== false);
+    if (state.tasks.length > 0 && tasksWithoutVerification.length > 0 && !hasRequiredGate) {
+        gaps.push({
+            id: 'missing-verification',
+            kind: 'missing-verification',
+            severity: 'blocking',
+            message: 'The plan has tasks but no verification gates or per-task verification.',
+            question: {
+                id: 'verification-gates',
+                prompt: 'How should this plan prove that the work is correct?',
+                whyItMatters: 'Verification gates keep execution from ending at code changes that were never checked.',
+                recommendedAnswer: 'Record concrete tests, commands, manual checks, or release gates for the changed behavior.',
+                consequence: 'The plan should not be executable until verification exists.',
+            },
+            relatedTaskIds: tasksWithoutVerification,
+        });
+    }
+    const blocking = gaps.some((gap) => gap.severity === 'blocking');
+    if (!blocking && !state.executionApproved) {
+        gaps.push({
+            id: 'unapproved-execution',
+            kind: 'unapproved-execution',
+            severity: 'blocking',
+            message: 'The plan is structurally ready but has not been approved for execution.',
+            question: {
+                id: 'approve-execution',
+                prompt: 'Is this plan approved for execution?',
+                whyItMatters: 'The TUI owns user approval before local work or agent assignments begin.',
+                recommendedAnswer: 'Approve only after the goal, scope, tasks, dependencies, and verification gates look right.',
+            },
+        });
+    }
+    const readiness = readinessFromGaps(gaps);
+    return {
+        ok: true,
+        projectId: state.projectId,
+        knowledgeSpaceId: state.knowledgeSpaceId,
+        readiness,
+        gaps,
+        ...(gaps[0]?.question ? { nextQuestion: gaps[0].question } : {}),
+        state: {
+            ...state,
+            readiness,
+        },
+    };
+}
+function readinessFromGaps(gaps) {
+    if (gaps.length === 0)
+        return 'executable';
+    if (gaps.some((gap) => gap.severity === 'blocking'))
+        return 'needs-user-input';
+    return 'not-ready';
+}
+function firstVagueTerm(value) {
+    const normalized = value.toLowerCase();
+    return VAGUE_TERMS.find((term) => normalized.includes(term)) ?? null;
+}
+function blockingQuestion(kind, message, prompt, whyItMatters, recommendedAnswer) {
+    const question = {
+        id: kind,
+        prompt,
+        whyItMatters,
+        recommendedAnswer,
+    };
+    return {
+        id: kind,
+        kind,
+        severity: 'blocking',
+        message,
+        question,
+    };
+}

package/dist/_internal/platform/knowledge/project-planning/service.d.ts

@@ -0,0 +1,25 @@
+import { KnowledgeStore } from '../store.js';
+import type { ProjectPlanningDecisionRecordInput, ProjectPlanningDecisionResult, ProjectPlanningDecisionsResult, ProjectPlanningEvaluateInput, ProjectPlanningEvaluation, ProjectPlanningLanguageResult, ProjectPlanningLanguageUpsertInput, ProjectPlanningSpaceInput, ProjectPlanningStateResult, ProjectPlanningStateUpsertInput, ProjectPlanningStatus } from './types.js';
+export interface ProjectPlanningServiceOptions {
+    readonly defaultProjectId?: string;
+}
+export declare class ProjectPlanningService {
+    private readonly store;
+    private readonly defaultProjectId;
+    constructor(store: KnowledgeStore, options?: ProjectPlanningServiceOptions);
+    status(input?: ProjectPlanningSpaceInput): Promise<ProjectPlanningStatus>;
+    getState(input?: ProjectPlanningSpaceInput & {
+        readonly planningId?: string;
+    }): Promise<ProjectPlanningStateResult>;
+    upsertState(input: ProjectPlanningStateUpsertInput): Promise<ProjectPlanningStateResult>;
+    evaluate(input?: ProjectPlanningEvaluateInput): Promise<ProjectPlanningEvaluation>;
+    listDecisions(input?: ProjectPlanningSpaceInput): Promise<ProjectPlanningDecisionsResult>;
+    recordDecision(input: ProjectPlanningDecisionRecordInput): Promise<ProjectPlanningDecisionResult>;
+    getLanguage(input?: ProjectPlanningSpaceInput): Promise<ProjectPlanningLanguageResult>;
+    upsertLanguage(input: ProjectPlanningLanguageUpsertInput): Promise<ProjectPlanningLanguageResult>;
+    private resolveSpace;
+    private sourcesForSpace;
+    private getArtifactSource;
+    private upsertArtifactSource;
+}
+//# sourceMappingURL=service.d.ts.map

package/dist/_internal/platform/knowledge/project-planning/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/knowledge/project-planning/service.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAa7C,OAAO,KAAK,EAEV,kCAAkC,EAClC,6BAA6B,EAC7B,8BAA8B,EAC9B,4BAA4B,EAC5B,yBAAyB,EAEzB,6BAA6B,EAC7B,kCAAkC,EAClC,yBAAyB,EAEzB,0BAA0B,EAC1B,+BAA+B,EAC/B,qBAAqB,EACtB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;CACpC;AAED,qBAAa,sBAAsB;IAI/B,OAAO,CAAC,QAAQ,CAAC,KAAK;IAHxB,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAS;gBAGvB,KAAK,EAAE,cAAc,EACtC,OAAO,GAAE,6BAAkC;IAKvC,MAAM,CAAC,KAAK,GAAE,yBAA8B,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAyB7E,QAAQ,CAAC,KAAK,GAAE,yBAAyB,GAAG;QAAE,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAO,GAAG,OAAO,CAAC,0BAA0B,CAAC;IAevH,WAAW,CAAC,KAAK,EAAE,+BAA+B,GAAG,OAAO,CAAC,0BAA0B,CAAC;IAgBxF,QAAQ,CAAC,KAAK,GAAE,4BAAiC,GAAG,OAAO,CAAC,yBAAyB,CAAC;IAWtF,aAAa,CAAC,KAAK,GAAE,yBAA8B,GAAG,OAAO,CAAC,8BAA8B,CAAC;IAgB7F,cAAc,CAAC,KAAK,EAAE,kCAAkC,GAAG,OAAO,CAAC,6BAA6B,CAAC;IA2BjG,WAAW,CAAC,KAAK,GAAE,yBAA8B,GAAG,OAAO,CAAC,6BAA6B,CAAC;IAc1F,cAAc,CAAC,KAAK,EAAE,kCAAkC,GAAG,OAAO,CAAC,6BAA6B,CAAC;IA2BvG,OAAO,CAAC,YAAY;IAIpB,OAAO,CAAC,eAAe;IAOvB,OAAO,CAAC,iBAAiB;YASX,oBAAoB;CAyBnC"}

package/dist/_internal/platform/knowledge/project-planning/service.js

@@ -0,0 +1,259 @@
+import { knowledgeSpaceMetadata, normalizeProjectId, } from '../spaces.js';
+import { KnowledgeStore } from '../store.js';
+import { PROJECT_PLANNING_CONNECTOR_ID, PROJECT_PLANNING_TAG, projectPlanningArtifactSummary, projectPlanningCanonicalUri, projectPlanningSourceId, readPlanningMetadataObject, resolveProjectPlanningSpace, stablePlanningId, } from './helpers.js';
+import { evaluateProjectPlanningReadiness } from './readiness.js';
+export class ProjectPlanningService {
+    store;
+    defaultProjectId;
+    constructor(store, options = {}) {
+        this.store = store;
+        this.defaultProjectId = normalizeProjectId(options.defaultProjectId ?? 'default');
+    }
+    async status(input = {}) {
+        await this.store.init();
+        const space = this.resolveSpace(input);
+        const sources = this.sourcesForSpace(space.knowledgeSpaceId);
+        return {
+            ok: true,
+            projectId: space.projectId,
+            knowledgeSpaceId: space.knowledgeSpaceId,
+            passiveOnly: true,
+            counts: {
+                states: sources.filter((source) => artifactKind(source) === 'state').length,
+                decisions: sources.filter((source) => artifactKind(source) === 'decision').length,
+                languageArtifacts: sources.filter((source) => artifactKind(source) === 'language').length,
+            },
+            capabilities: [
+                'project-scoped-storage',
+                'planning-state-validation',
+                'project-language-artifacts',
+                'decision-records',
+                'agent-task-graph-metadata',
+                'passive-daemon-only',
+            ],
+        };
+    }
+    async getState(input = {}) {
+        await this.store.init();
+        const space = this.resolveSpace(input);
+        const planningId = normalizePlanningId(input.planningId);
+        const source = this.getArtifactSource(space.knowledgeSpaceId, 'state', planningId);
+        const state = source ? readState(source) : null;
+        return {
+            ok: true,
+            projectId: space.projectId,
+            knowledgeSpaceId: space.knowledgeSpaceId,
+            state,
+            ...(source ? { source } : {}),
+        };
+    }
+    async upsertState(input) {
+        await this.store.init();
+        const space = this.resolveSpace(input);
+        const state = normalizeState(input.state, space.projectId, space.knowledgeSpaceId);
+        const evaluation = evaluateProjectPlanningReadiness(state);
+        const normalized = evaluation.state;
+        const source = await this.upsertArtifactSource(space, 'state', normalized.id, normalized);
+        return {
+            ok: true,
+            projectId: space.projectId,
+            knowledgeSpaceId: space.knowledgeSpaceId,
+            state: normalized,
+            source,
+        };
+    }
+    async evaluate(input = {}) {
+        await this.store.init();
+        const space = this.resolveSpace(input);
+        if (input.state) {
+            return evaluateProjectPlanningReadiness(normalizeState(input.state, space.projectId, space.knowledgeSpaceId));
+        }
+        const stateResult = await this.getState({ ...space, planningId: input.planningId });
+        const state = stateResult.state ?? normalizeState({}, space.projectId, space.knowledgeSpaceId);
+        return evaluateProjectPlanningReadiness(state);
+    }
+    async listDecisions(input = {}) {
+        await this.store.init();
+        const space = this.resolveSpace(input);
+        const decisions = this.sourcesForSpace(space.knowledgeSpaceId)
+            .filter((source) => artifactKind(source) === 'decision')
+            .map(readDecision)
+            .filter((decision) => decision !== null)
+            .sort((a, b) => (b.updatedAt ?? b.createdAt ?? 0) - (a.updatedAt ?? a.createdAt ?? 0));
+        return {
+            ok: true,
+            projectId: space.projectId,
+            knowledgeSpaceId: space.knowledgeSpaceId,
+            decisions,
+        };
+    }
+    async recordDecision(input) {
+        await this.store.init();
+        const space = this.resolveSpace(input);
+        const now = Date.now();
+        const decision = {
+            id: input.decision.id ?? stablePlanningId('decision', input.decision.title),
+            title: input.decision.title.trim(),
+            ...(input.decision.context ? { context: input.decision.context } : {}),
+            decision: input.decision.decision.trim(),
+            ...(input.decision.alternatives ? { alternatives: [...input.decision.alternatives] } : {}),
+            ...(input.decision.reasoning ? { reasoning: input.decision.reasoning } : {}),
+            ...(input.decision.consequences ? { consequences: [...input.decision.consequences] } : {}),
+            status: input.decision.status ?? 'accepted',
+            createdAt: input.decision.createdAt ?? now,
+            updatedAt: now,
+            ...(input.decision.metadata ? { metadata: { ...input.decision.metadata } } : {}),
+        };
+        const source = await this.upsertArtifactSource(space, 'decision', decision.id, decision);
+        return {
+            ok: true,
+            projectId: space.projectId,
+            knowledgeSpaceId: space.knowledgeSpaceId,
+            decision,
+            source,
+        };
+    }
+    async getLanguage(input = {}) {
+        await this.store.init();
+        const space = this.resolveSpace(input);
+        const source = this.getArtifactSource(space.knowledgeSpaceId, 'language', 'current');
+        const language = source ? readLanguage(source) : null;
+        return {
+            ok: true,
+            projectId: space.projectId,
+            knowledgeSpaceId: space.knowledgeSpaceId,
+            language,
+            ...(source ? { source } : {}),
+        };
+    }
+    async upsertLanguage(input) {
+        await this.store.init();
+        const space = this.resolveSpace(input);
+        const now = Date.now();
+        const existing = await this.getLanguage(space);
+        const language = {
+            projectId: space.projectId,
+            knowledgeSpaceId: space.knowledgeSpaceId,
+            terms: input.language.terms ? [...input.language.terms] : existing.language?.terms ?? [],
+            ambiguities: input.language.ambiguities ? [...input.language.ambiguities] : existing.language?.ambiguities ?? [],
+            ...(input.language.examples ? { examples: [...input.language.examples] } : existing.language?.examples ? { examples: existing.language.examples } : {}),
+            updatedAt: now,
+            metadata: {
+                ...(existing.language?.metadata ?? {}),
+                ...(input.language.metadata ?? {}),
+            },
+        };
+        const source = await this.upsertArtifactSource(space, 'language', 'current', language);
+        return {
+            ok: true,
+            projectId: space.projectId,
+            knowledgeSpaceId: space.knowledgeSpaceId,
+            language,
+            source,
+        };
+    }
+    resolveSpace(input = {}) {
+        return resolveProjectPlanningSpace(input, this.defaultProjectId);
+    }
+    sourcesForSpace(spaceId) {
+        return this.store.listSources(10_000).filter((source) => {
+            const metadata = source.metadata ?? {};
+            return metadata.projectPlanning === true && metadata.knowledgeSpaceId === spaceId;
+        });
+    }
+    getArtifactSource(spaceId, kind, id) {
+        const sourceId = projectPlanningSourceId(spaceId, kind, id);
+        return this.store.getSource(sourceId) ?? this.store.getSourceByCanonicalUri(projectPlanningCanonicalUri(spaceId, kind, id));
+    }
+    async upsertArtifactSource(space, kind, id, value) {
+        const spaceId = space.knowledgeSpaceId;
+        return this.store.upsertSource({
+            id: projectPlanningSourceId(spaceId, kind, id),
+            connectorId: PROJECT_PLANNING_CONNECTOR_ID,
+            sourceType: 'dataset',
+            title: titleForArtifact(kind, value),
+            canonicalUri: projectPlanningCanonicalUri(spaceId, kind, id),
+            summary: projectPlanningArtifactSummary(kind, value),
+            tags: [PROJECT_PLANNING_TAG, `project-planning:${kind}`],
+            status: 'indexed',
+            metadata: knowledgeSpaceMetadata(spaceId, {
+                projectPlanning: true,
+                planningArtifactKind: kind,
+                planningArtifactId: id,
+                projectId: space.projectId,
+                value,
+            }),
+        });
+    }
+}
+function normalizeState(input, projectId, knowledgeSpaceId) {
+    const now = Date.now();
+    const id = normalizePlanningId(input.id);
+    return {
+        id,
+        projectId,
+        knowledgeSpaceId,
+        goal: typeof input.goal === 'string' ? input.goal : '',
+        ...(typeof input.scope === 'string' ? { scope: input.scope } : {}),
+        knownContext: arrayOfObjectsOrStrings(input.knownContext),
+        openQuestions: arrayOfObjects(input.openQuestions),
+        answeredQuestions: arrayOfObjects(input.answeredQuestions),
+        decisions: arrayOfObjects(input.decisions),
+        assumptions: arrayOfObjectsOrStrings(input.assumptions),
+        constraints: arrayOfObjectsOrStrings(input.constraints),
+        risks: arrayOfObjectsOrStrings(input.risks),
+        tasks: arrayOfObjects(input.tasks),
+        dependencies: arrayOfObjects(input.dependencies),
+        verificationGates: arrayOfObjects(input.verificationGates),
+        agentAssignments: arrayOfObjects(input.agentAssignments),
+        readiness: input.readiness ?? 'not-ready',
+        executionApproved: input.executionApproved === true,
+        createdAt: typeof input.createdAt === 'number' ? input.createdAt : now,
+        updatedAt: now,
+        metadata: readPlanningMetadataObject(input.metadata),
+    };
+}
+function normalizePlanningId(value) {
+    return typeof value === 'string' && value.trim().length > 0
+        ? stablePlanningId('plan', value)
+        : 'current';
+}
+function arrayOfObjects(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((entry) => !!entry && typeof entry === 'object' && !Array.isArray(entry));
+}
+function arrayOfObjectsOrStrings(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((entry) => {
+        if (typeof entry === 'string')
+            return [entry];
+        if (entry && typeof entry === 'object' && 'text' in entry && typeof entry.text === 'string')
+            return [entry.text];
+        return [];
+    });
+}
+function artifactKind(source) {
+    const kind = source.metadata.planningArtifactKind;
+    return kind === 'state' || kind === 'decision' || kind === 'language' ? kind : null;
+}
+function readState(source) {
+    const value = source.metadata.value;
+    return value && typeof value === 'object' ? value : null;
+}
+function readDecision(source) {
+    const value = source.metadata.value;
+    return value && typeof value === 'object' ? value : null;
+}
+function readLanguage(source) {
+    const value = source.metadata.value;
+    return value && typeof value === 'object' ? value : null;
+}
+function titleForArtifact(kind, value) {
+    if (kind === 'state')
+        return `Planning: ${value.goal || 'Current plan'}`;
+    if (kind === 'decision')
+        return `Decision: ${value.title}`;
+    return 'Project Language';
+}