newo 3.7.3 → 3.7.4

package/CHANGELOG.md

@@ -7,6 +7,25 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [3.7.4] - 2026-06-10
+
+### Added
+
+- **V2 push now creates new skills from inline flow YAML definitions.** Previously the `newo_v2` push path could only update content of skills already known to the local project map; a skill added locally to `{FlowIdn}.yaml` after the last pull was silently ignored, leaving its `.nsl`/`.nslg` script with no way to reach the platform. `V2ProjectSyncStrategy.push()` now reconciles inline skill metadata before iterating script changes: missing remote skills are created via `POST /api/v1/designer/flows/{flowId}/skills`, race-condition duplicates (already-exists on create) fall back to fetching the remote skill via `listFlowSkills` and updating it, and missing skill parameters are filled in via `POST /api/v1/designer/flows/skills/{skillId}/parameters`. The local project map and SHA256 hash store are updated atomically after the reconciliation pass.
+- **Strict model validation before V2 skill writes.** New `assertSkillModelResolved` helper throws a descriptive error ("Set either skill.model.* or flow default_model_idn/default_provider_idn") when neither the inline skill nor the flow declares a model/provider, instead of letting the platform return a generic 4xx with no hint about which YAML field is missing.
+- **33 unit tests** in `test/v2-push-helpers.test.js` covering `isAlreadyExistsApiError`, `assertSkillModelResolved`, `normalizeRunnerType`, `normalizeParameters`, `skillMetadataDiffers`, `buildV2SkillMetadataFromYaml`, and `createMissingSkillParameters` (stubbed API client). Regression-locks the false-positive matcher fix, the model-validation contract, the parameter-creation counting, and the model-key-order false positive.
+
+### Fixed
+
+- **`isAlreadyExistsApiError` no longer matches "does not exist".** The previous detector accepted any 400/409/422 response whose body contained the substring `"exist"`, which incorrectly classified "Skill does not exist" / "Flow doesn't exist" errors as duplicates and triggered a spurious reuse fallback. The matcher is now tightened to only `"already exists"` and `"duplicate key"`.
+- **`validate()` reports missing scripts for YAML-declared skills.** Previously `V2ProjectSyncStrategy.validate()` only checked scripts listed in the local map; skills added directly to `{FlowIdn}.yaml` since the last pull were never validated. Validation now walks the YAML when present and surfaces a `Script file not found:` error per skill, matching the new push contract.
+- **Missing-script skills are reported, not silently skipped.** Instead of a `verbose`-only "Skipping skill without local script" log, the push now records `[newo_v2] Missing script for skill {project}/{agent}/{flow}/{skill}: {path}` in the push errors. Failures are isolated per skill: one broken skill no longer aborts the push of every other flow/project in the workspace.
+- **Model validation only runs before actual platform writes.** `assertSkillModelResolved` fires only when a skill is about to be created or its metadata updated — a pre-existing flow YAML without `skill.model.*` / flow `default_model_idn` no longer blocks pushes of unrelated, untouched skills.
+- **Parameter-creation count is no longer inflated by already-existing parameters.** `createMissingSkillParameters` incremented its counter (and logged "Created skill parameter") even when the platform answered "already exists", which spuriously triggered a follow-up `updateSkill` call. Count and log now happen only on successful creation.
+- **`isAlreadyExistsApiError` no longer throws on `null`/`undefined` errors** (optional chaining on `.response`), which previously masked the original failure inside catch handlers.
+- **`skillMetadataDiffers` no longer flags every skill as changed.** The model comparison used `JSON.stringify`, which is key-order-sensitive: the project map stores `{provider_idn, model_idn}` (platform API order) while YAML-built metadata uses `{model_idn, provider_idn}`. Verified against a live account: every push rewrote all 1342 skills. Model is now compared field-by-field and parameters are compared order-insensitively (sorted by name).
+- **Skill parameters are now created explicitly after `createSkill`.** The platform's create endpoint ignores inline `parameters` in the request body (verified against the live platform) — newly created skills silently lost their YAML-declared parameters. The create path now calls `POST /flows/skills/{skillId}/parameters` per parameter, same as the update path.
+
 ## [3.7.3] - 2026-05-25
 
 ### Fixed
@@ -1061,7 +1080,8 @@ Another Item: $Price [Modifiers: modifier3]
 - GitHub Actions CI/CD integration
 - Robust authentication with token refresh
 
-[Unreleased]: https://github.com/sabbah13/newo-cli/compare/v3.7.3...HEAD
+[Unreleased]: https://github.com/sabbah13/newo-cli/compare/v3.7.4...HEAD
+[3.7.4]: https://github.com/sabbah13/newo-cli/compare/v3.7.3...v3.7.4
 [3.7.3]: https://github.com/sabbah13/newo-cli/compare/v3.7.2...v3.7.3
 [3.7.2]: https://github.com/sabbah13/newo-cli/compare/v3.7.1...v3.7.2
 [3.7.1]: https://github.com/sabbah13/newo-cli/compare/v3.7.0...v3.7.1

package/README.md

@@ -8,6 +8,7 @@
 **NEWO CLI** - Professional command-line tool for NEWO AI Agent development. Features **modular architecture**, **IDN-based file management**, and **comprehensive multi-customer support**.
 
 Sync NEWO "Project → Agent → Flow → Skills" structure to local files with:
+- 🆕 **V2 skill creation on push** (v3.7.4) - adding a skill inline to a `newo_v2` `{FlowIdn}.yaml` and pushing now creates it on the platform (previously only updates of existing skills worked)
 - 🆕 **Canvas blank-screen hardening** (v3.7.3) - JSON-typed attributes (e.g. Workflow Builder canvas) with Markdown `\_` escapes or structural newlines no longer corrupt the canvas on push ([#7](https://github.com/sabbah13/newo-cli/pull/7))
 - 🆕 **Flow metadata sync** (v3.7.2) - `newo push` now reconciles flow title, events, and state_fields from local `metadata.yaml` to the platform (closes [#3](https://github.com/sabbah13/newo-cli/issues/3))
 - 🆕 **Dual format support** (v3.6.0) - `cli_v1` (native) and `newo_v2` (platform compatible), auto-detected per customer

package/dist/domain/strategies/sync/V2ProjectSyncStrategy.d.ts

@@ -65,6 +65,39 @@ export declare class V2ProjectSyncStrategy implements ISyncStrategy<ProjectMeta,
      * shared syncFlowMetadata routine that calls PATCH/POST/DELETE per child.
      */
     private pushV2FlowYamlUpdate;
+    /**
+     * Reconcile inline skill definitions from V2 flow YAML before pushing scripts.
+     *
+     * V2 keeps skill metadata (model, runner_type, parameters) in the flow YAML,
+     * not in a separate skill metadata file. The map only contains the remote IDs
+     * from a previous pull, so new local skills must be created before their
+     * callers can be published.
+     */
+    private syncV2FlowYamlDefinitions;
+    private createMissingSkillParameters;
+    /**
+     * Detect "resource already exists" API errors.
+     *
+     * Matches only on the precise phrases the platform actually returns
+     * ("already exists", "duplicate key"). Loose substrings like "exist"
+     * would otherwise sweep up unrelated "does not exist" / "doesn't exist"
+     * errors and trigger an incorrect reuse fallback.
+     */
+    private isAlreadyExistsApiError;
+    private normalizeRunnerType;
+    private normalizeParameters;
+    /**
+     * Fail fast if no model could be resolved for a V2 skill.
+     *
+     * `buildV2SkillMetadataFromYaml` falls back to empty strings when neither
+     * the skill nor the flow declare a model. The platform rejects empty
+     * model_idn/provider_idn at creation/update time, but the error it returns
+     * is generic — we surface a clearer message before issuing the request.
+     */
+    private assertSkillModelResolved;
+    private buildV2SkillMetadataFromYaml;
+    private skillMetadataDiffers;
+    private resolveV2FlowSkillScriptPath;
     /**
      * Push a V2 skill update
      *
@@ -81,6 +114,7 @@ export declare class V2ProjectSyncStrategy implements ISyncStrategy<ProjectMeta,
      */
     private publishAllFlows;
     getChanges(customer: CustomerConfig): Promise<ChangeItem<LocalProjectData>[]>;
+    private loadLocalV2FlowSkills;
     validate(customer: CustomerConfig, _items: LocalProjectData[]): Promise<ValidationResult>;
     getStatus(customer: CustomerConfig): Promise<StatusSummary>;
 }

package/dist/domain/strategies/sync/V2ProjectSyncStrategy.js

@@ -14,13 +14,13 @@
  *           skills/{SkillIdn}.nsl|.nslg
  */
 import fs from 'fs-extra';
-import { listProjects, listAgents, listFlowSkills, listFlowEvents, listFlowStates, updateSkill, publishFlow, getProjectAttributes, getCustomerAttributes, listLibraries, updateLibrarySkill, getFlow, } from '../../../api.js';
+import { listProjects, listAgents, listFlowSkills, listFlowEvents, listFlowStates, createSkill, createSkillParameter, updateSkill, publishFlow, getProjectAttributes, getCustomerAttributes, listLibraries, updateLibrarySkill, getFlow, } from '../../../api.js';
 import { syncFlowMetadata, emptyFlowSyncCounts, totalFlowSyncOps, describeFlowSyncCounts } from '../../../sync/flow-metadata.js';
 import { ensureStateOnly, writeFileSafe, mapPath, } from '../../../fsutil.js';
 import { sha256, saveHashes, loadHashes } from '../../../hash.js';
-import { v2ImportVersionPath, v2ProjectYamlPath, v2AgentYamlPath, v2FlowYamlPath, v2SkillScriptPath, v2SkillRelativePath, v2ProjectAttributesPath, v2CustomerAttributesPath, v2AkbDir, v2AkbPath, v2LibraryYamlPath, v2LibrarySkillScriptPath, v2LibrarySkillRelativePath, } from '../../../format/paths-v2.js';
+import { v2ImportVersionPath, v2ProjectYamlPath, v2AgentDir, v2AgentYamlPath, v2FlowYamlPath, v2SkillScriptPath, v2SkillRelativePath, v2ProjectAttributesPath, v2CustomerAttributesPath, v2AkbDir, v2AkbPath, v2LibraryYamlPath, v2LibrarySkillScriptPath, v2LibrarySkillRelativePath, } from '../../../format/paths-v2.js';
 import { V2_IMPORT_VERSION, } from '../../../format/types.js';
-import { generateV2FlowYaml, generateV2ProjectYaml, generateV2AgentYaml, buildV2InlineSkill, buildV2FlowEvent, buildV2StateField, parseV2FlowYaml, } from '../../../format/v2-yaml.js';
+import { generateV2FlowYaml, generateV2ProjectYaml, generateV2AgentYaml, parseV2FlowYaml, buildV2InlineSkill, buildV2FlowEvent, buildV2StateField, } from '../../../format/v2-yaml.js';
 import { isContentDifferent } from '../../../sync/skill-files.js';
 import yaml from 'js-yaml';
 import { patchYamlToPyyaml } from '../../../format/yaml-patch.js';
@@ -438,8 +438,15 @@ export class V2ProjectSyncStrategy {
             return result;
         }
         const mapData = await fs.readJson(mapFile);
+        const metadataSync = await this.syncV2FlowYamlDefinitions(client, customer, mapData, newHashes);
+        result.created += metadataSync.created;
+        result.updated += metadataSync.updated;
+        result.errors.push(...metadataSync.errors);
         for (const change of changes) {
             try {
+                if (metadataSync.syncedPaths.has(change.path)) {
+                    continue;
+                }
                 if (change.operation === 'modified') {
                     // V2 flow YAML: newo_customers/{cust}/{proj}/agents/{agent}/flows/{flow}/{flow}.yaml
                     // The flow YAML carries title, events, and state_fields inline, so
@@ -461,6 +468,9 @@ export class V2ProjectSyncStrategy {
                 result.errors.push(`Failed to push ${change.path}: ${error instanceof Error ? error.message : String(error)}`);
             }
         }
+        if (metadataSync.created > 0 || metadataSync.updated > 0) {
+            await writeFileSafe(mapFile, JSON.stringify(mapData, null, 2));
+        }
         await saveHashes(newHashes, customer.idn);
         if (result.created > 0 || result.updated > 0) {
             await this.publishAllFlows(client, mapData);
@@ -564,6 +574,245 @@ export class V2ProjectSyncStrategy {
         newHashes[change.path] = sha256(content);
         return total;
     }
+    /**
+     * Reconcile inline skill definitions from V2 flow YAML before pushing scripts.
+     *
+     * V2 keeps skill metadata (model, runner_type, parameters) in the flow YAML,
+     * not in a separate skill metadata file. The map only contains the remote IDs
+     * from a previous pull, so new local skills must be created before their
+     * callers can be published.
+     */
+    async syncV2FlowYamlDefinitions(client, customer, mapData, newHashes) {
+        let created = 0;
+        let updated = 0;
+        const syncedPaths = new Set();
+        const errors = [];
+        for (const [projectIdn, projectData] of Object.entries(mapData.projects)) {
+            for (const [agentIdn, agentData] of Object.entries(projectData.agents)) {
+                for (const [flowIdn, flowData] of Object.entries(agentData.flows)) {
+                    const flowYamlPath = v2FlowYamlPath(customer.idn, projectIdn, agentIdn, flowIdn);
+                    if (!(await fs.pathExists(flowYamlPath))) {
+                        continue;
+                    }
+                    let flowDef;
+                    try {
+                        flowDef = await parseV2FlowYaml(flowYamlPath);
+                    }
+                    catch (error) {
+                        this.logger.warn(`[newo_v2] Failed to parse flow YAML ${flowYamlPath}: ${error instanceof Error ? error.message : String(error)}`);
+                        continue;
+                    }
+                    for (const skill of flowDef.skills || []) {
+                        const skillLocator = `${projectIdn}/${agentIdn}/${flowIdn}/${skill.idn}`;
+                        // Per-skill failure isolation: one broken skill must not abort the
+                        // push of every other project/flow in the workspace.
+                        try {
+                            const runnerType = this.normalizeRunnerType(skill.runner_type);
+                            const scriptPath = await this.resolveV2FlowSkillScriptPath(customer.idn, projectIdn, agentIdn, flowIdn, skill.idn, runnerType, skill.prompt_script);
+                            if (!(await fs.pathExists(scriptPath))) {
+                                errors.push(`[newo_v2] Missing script for skill ${skillLocator}: ${scriptPath}`);
+                                continue;
+                            }
+                            const content = await fs.readFile(scriptPath, 'utf8');
+                            const localMetadata = this.buildV2SkillMetadataFromYaml(skill, flowDef, runnerType, flowData.skills[skill.idn]);
+                            const existingSkill = flowData.skills[skill.idn];
+                            if (!existingSkill) {
+                                this.assertSkillModelResolved(localMetadata, skillLocator);
+                                try {
+                                    const createdSkill = await createSkill(client, flowData.id, {
+                                        idn: localMetadata.idn,
+                                        title: localMetadata.title,
+                                        prompt_script: content,
+                                        runner_type: localMetadata.runner_type,
+                                        model: localMetadata.model,
+                                        parameters: localMetadata.parameters,
+                                        path: localMetadata.path || ''
+                                    });
+                                    // The create endpoint ignores inline `parameters` (verified
+                                    // against the live platform) — create them explicitly.
+                                    await this.createMissingSkillParameters(client, { ...localMetadata, id: createdSkill.id, parameters: [] }, localMetadata);
+                                    flowData.skills[skill.idn] = {
+                                        ...localMetadata,
+                                        id: createdSkill.id
+                                    };
+                                    newHashes[scriptPath] = sha256(content);
+                                    syncedPaths.add(scriptPath);
+                                    created++;
+                                    this.logger.info(`[newo_v2] Created skill: ${flowIdn}/${skill.idn}`);
+                                }
+                                catch (error) {
+                                    if (!this.isAlreadyExistsApiError(error)) {
+                                        throw error;
+                                    }
+                                    const remoteSkills = await listFlowSkills(client, flowData.id);
+                                    const remoteSkill = remoteSkills.find(s => s.idn === skill.idn);
+                                    if (!remoteSkill) {
+                                        throw error;
+                                    }
+                                    const remoteMetadata = {
+                                        id: remoteSkill.id,
+                                        idn: remoteSkill.idn,
+                                        title: remoteSkill.title,
+                                        runner_type: remoteSkill.runner_type,
+                                        model: remoteSkill.model,
+                                        parameters: this.normalizeParameters(remoteSkill.parameters),
+                                        path: remoteSkill.path
+                                    };
+                                    await this.createMissingSkillParameters(client, remoteMetadata, localMetadata);
+                                    await updateSkill(client, {
+                                        id: remoteSkill.id,
+                                        title: localMetadata.title,
+                                        idn: localMetadata.idn,
+                                        prompt_script: content,
+                                        runner_type: localMetadata.runner_type,
+                                        model: localMetadata.model,
+                                        parameters: localMetadata.parameters,
+                                        path: remoteSkill.path || localMetadata.path
+                                    });
+                                    flowData.skills[skill.idn] = {
+                                        ...localMetadata,
+                                        id: remoteSkill.id,
+                                        path: remoteSkill.path || localMetadata.path
+                                    };
+                                    newHashes[scriptPath] = sha256(content);
+                                    syncedPaths.add(scriptPath);
+                                    updated++;
+                                    this.logger.info(`[newo_v2] Reused existing skill: ${flowIdn}/${skill.idn}`);
+                                }
+                                continue;
+                            }
+                            const createdParameters = await this.createMissingSkillParameters(client, existingSkill, localMetadata);
+                            if (createdParameters > 0 || this.skillMetadataDiffers(existingSkill, localMetadata)) {
+                                this.assertSkillModelResolved(localMetadata, skillLocator);
+                                await updateSkill(client, {
+                                    id: existingSkill.id,
+                                    title: localMetadata.title,
+                                    idn: localMetadata.idn,
+                                    prompt_script: content,
+                                    runner_type: localMetadata.runner_type,
+                                    model: localMetadata.model,
+                                    parameters: localMetadata.parameters,
+                                    path: localMetadata.path
+                                });
+                                flowData.skills[skill.idn] = {
+                                    ...localMetadata,
+                                    id: existingSkill.id
+                                };
+                                newHashes[scriptPath] = sha256(content);
+                                syncedPaths.add(scriptPath);
+                                updated++;
+                                this.logger.info(`[newo_v2] Updated skill metadata: ${flowIdn}/${skill.idn}`);
+                            }
+                        }
+                        catch (error) {
+                            errors.push(`Failed to sync skill ${skillLocator}: ${error instanceof Error ? error.message : String(error)}`);
+                        }
+                    }
+                }
+            }
+        }
+        return { created, updated, syncedPaths, errors };
+    }
+    async createMissingSkillParameters(client, existing, local) {
+        const existingNames = new Set(this.normalizeParameters(existing.parameters).map(p => p.name));
+        let created = 0;
+        for (const parameter of local.parameters) {
+            if (existingNames.has(parameter.name)) {
+                continue;
+            }
+            try {
+                await createSkillParameter(client, existing.id, {
+                    name: parameter.name,
+                    default_value: parameter.default_value ?? ''
+                });
+                created++;
+                this.logger.info(`[newo_v2] Created skill parameter: ${local.idn}/${parameter.name}`);
+            }
+            catch (error) {
+                if (!this.isAlreadyExistsApiError(error)) {
+                    throw error;
+                }
+            }
+            existingNames.add(parameter.name);
+        }
+        return created;
+    }
+    /**
+     * Detect "resource already exists" API errors.
+     *
+     * Matches only on the precise phrases the platform actually returns
+     * ("already exists", "duplicate key"). Loose substrings like "exist"
+     * would otherwise sweep up unrelated "does not exist" / "doesn't exist"
+     * errors and trigger an incorrect reuse fallback.
+     */
+    isAlreadyExistsApiError(error) {
+        const response = error?.response;
+        const status = response?.status;
+        if (status !== 400 && status !== 409 && status !== 422) {
+            return false;
+        }
+        const haystack = JSON.stringify(response?.data ?? (error instanceof Error ? error.message : String(error))).toLowerCase();
+        return haystack.includes('already exists') || haystack.includes('duplicate key');
+    }
+    normalizeRunnerType(runnerType) {
+        return runnerType === 'nsl' ? 'nsl' : 'guidance';
+    }
+    normalizeParameters(parameters) {
+        return (parameters || []).map(p => ({
+            name: p.name,
+            default_value: p.default_value ?? ''
+        }));
+    }
+    /**
+     * Fail fast if no model could be resolved for a V2 skill.
+     *
+     * `buildV2SkillMetadataFromYaml` falls back to empty strings when neither
+     * the skill nor the flow declare a model. The platform rejects empty
+     * model_idn/provider_idn at creation/update time, but the error it returns
+     * is generic — we surface a clearer message before issuing the request.
+     */
+    assertSkillModelResolved(metadata, locator) {
+        if (!metadata.model.model_idn || !metadata.model.provider_idn) {
+            throw new Error(`[newo_v2] Cannot resolve model for skill ${locator}: ` +
+                `model_idn="${metadata.model.model_idn}", provider_idn="${metadata.model.provider_idn}". ` +
+                `Set either skill.model.* or flow default_model_idn/default_provider_idn in the flow YAML.`);
+        }
+    }
+    buildV2SkillMetadataFromYaml(skill, flowDef, runnerType, existing) {
+        return {
+            id: existing?.id || '',
+            idn: skill.idn,
+            title: skill.title || '',
+            runner_type: runnerType,
+            model: {
+                model_idn: skill.model?.model_idn || flowDef.default_model_idn || '',
+                provider_idn: skill.model?.provider_idn || flowDef.default_provider_idn || ''
+            },
+            parameters: this.normalizeParameters(skill.parameters),
+            path: existing?.path || ''
+        };
+    }
+    skillMetadataDiffers(existing, local) {
+        // Compare model/parameters field-by-field, never via JSON.stringify of the
+        // raw objects: the map stores model keys in platform API order
+        // (provider_idn first) while YAML-built metadata uses model_idn first, and
+        // a key-order-sensitive comparison flags every skill as changed.
+        const paramsKey = (params) => JSON.stringify(this.normalizeParameters(params).sort((a, b) => a.name.localeCompare(b.name)));
+        return (existing.title !== local.title ||
+            existing.runner_type !== local.runner_type ||
+            existing.model.model_idn !== local.model.model_idn ||
+            existing.model.provider_idn !== local.model.provider_idn ||
+            paramsKey(existing.parameters) !== paramsKey(local.parameters));
+    }
+    async resolveV2FlowSkillScriptPath(customerIdn, projectIdn, agentIdn, flowIdn, skillIdn, runnerType, promptScript) {
+        if (promptScript) {
+            const fromPromptScript = `${v2AgentDir(customerIdn, projectIdn, agentIdn)}/${promptScript}`;
+            if (await fs.pathExists(fromPromptScript)) {
+                return fromPromptScript;
+            }
+        }
+        return v2SkillScriptPath(customerIdn, projectIdn, agentIdn, flowIdn, skillIdn, runnerType);
+    }
     /**
      * Push a V2 skill update
      *
@@ -686,8 +935,18 @@ export class V2ProjectSyncStrategy {
                     }
                 }
                 for (const [flowIdn, flowData] of Object.entries(agentData.flows)) {
-                    for (const [skillIdn, skillMeta] of Object.entries(flowData.skills)) {
-                        const scriptPath = v2SkillScriptPath(customer.idn, projectIdn, agentIdn, flowIdn, skillIdn, skillMeta.runner_type);
+                    const flowYamlSkills = await this.loadLocalV2FlowSkills(customer.idn, projectIdn, agentIdn, flowIdn);
+                    const skillIdns = new Set([
+                        ...Object.keys(flowData.skills),
+                        ...flowYamlSkills.keys()
+                    ]);
+                    for (const skillIdn of skillIdns) {
+                        const yamlSkill = flowYamlSkills.get(skillIdn);
+                        const skillMeta = flowData.skills[skillIdn];
+                        const runnerType = this.normalizeRunnerType(yamlSkill?.runner_type || skillMeta?.runner_type);
+                        const scriptPath = yamlSkill
+                            ? await this.resolveV2FlowSkillScriptPath(customer.idn, projectIdn, agentIdn, flowIdn, skillIdn, runnerType, yamlSkill.prompt_script)
+                            : v2SkillScriptPath(customer.idn, projectIdn, agentIdn, flowIdn, skillIdn, runnerType);
                         if (await fs.pathExists(scriptPath)) {
                             const content = await fs.readFile(scriptPath, 'utf8');
                             const currentHash = sha256(content);
@@ -726,6 +985,19 @@ export class V2ProjectSyncStrategy {
         }
         return changes;
     }
+    async loadLocalV2FlowSkills(customerIdn, projectIdn, agentIdn, flowIdn) {
+        const flowYamlPath = v2FlowYamlPath(customerIdn, projectIdn, agentIdn, flowIdn);
+        if (!(await fs.pathExists(flowYamlPath))) {
+            return new Map();
+        }
+        try {
+            const flowDef = await parseV2FlowYaml(flowYamlPath);
+            return new Map((flowDef.skills || []).map(skill => [skill.idn, skill]));
+        }
+        catch {
+            return new Map();
+        }
+    }
     async validate(customer, _items) {
         const errors = [];
         const mapFile = mapPath(customer.idn);
@@ -741,7 +1013,46 @@ export class V2ProjectSyncStrategy {
         for (const [projectIdn, projectData] of Object.entries(mapData.projects)) {
             for (const [agentIdn, agentData] of Object.entries(projectData.agents)) {
                 for (const [flowIdn, flowData] of Object.entries(agentData.flows)) {
+                    const flowYamlPath = v2FlowYamlPath(customer.idn, projectIdn, agentIdn, flowIdn);
+                    let localYamlSkills;
+                    if (await fs.pathExists(flowYamlPath)) {
+                        try {
+                            const flowDef = await parseV2FlowYaml(flowYamlPath);
+                            localYamlSkills = new Map((flowDef.skills || []).map(s => [s.idn, s]));
+                            const skillIdns = new Set([
+                                ...Object.keys(flowData.skills),
+                                ...localYamlSkills.keys()
+                            ]);
+                            for (const skillIdn of skillIdns) {
+                                const localYamlSkill = localYamlSkills.get(skillIdn);
+                                const skillMeta = flowData.skills[skillIdn];
+                                if (!localYamlSkill) {
+                                    errors.push({
+                                        field: `skill.${skillIdn}`,
+                                        message: `Skill exists in project map but is missing from flow YAML: ${flowYamlPath}`,
+                                        path: flowYamlPath
+                                    });
+                                    continue;
+                                }
+                                const runnerType = this.normalizeRunnerType(localYamlSkill.runner_type || skillMeta?.runner_type);
+                                const scriptPath = await this.resolveV2FlowSkillScriptPath(customer.idn, projectIdn, agentIdn, flowIdn, skillIdn, runnerType, localYamlSkill.prompt_script);
+                                if (!(await fs.pathExists(scriptPath))) {
+                                    errors.push({
+                                        field: `skill.${localYamlSkill.idn}`,
+                                        message: `Script file not found: ${scriptPath}`,
+                                        path: scriptPath
+                                    });
+                                }
+                            }
+                        }
+                        catch {
+                            localYamlSkills = undefined;
+                        }
+                    }
                     for (const [skillIdn, skillMeta] of Object.entries(flowData.skills)) {
+                        if (localYamlSkills) {
+                            continue;
+                        }
                         const scriptPath = v2SkillScriptPath(customer.idn, projectIdn, agentIdn, flowIdn, skillIdn, skillMeta.runner_type);
                         if (!(await fs.pathExists(scriptPath))) {
                             errors.push({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newo",
-  "version": "3.7.3",
+  "version": "3.7.4",
   "description": "NEWO CLI: Professional command-line tool with modular architecture for NEWO AI Agent development. Features account migration, integration management, webhook automation, AKB knowledge base, project attributes, sandbox testing, IDN-based file management, real-time progress tracking, intelligent sync operations, and comprehensive multi-customer support.",
   "type": "module",
   "bin": {

package/src/domain/strategies/sync/V2ProjectSyncStrategy.ts

@@ -46,6 +46,8 @@ import {
   listFlowSkills,
   listFlowEvents,
   listFlowStates,
+  createSkill,
+  createSkillParameter,
   updateSkill,
   publishFlow,
   getProjectAttributes,
@@ -70,6 +72,7 @@ import { sha256, saveHashes, loadHashes } from '../../../hash.js';
 import {
   v2ImportVersionPath,
   v2ProjectYamlPath,
+  v2AgentDir,
   v2AgentYamlPath,
   v2FlowYamlPath,
   v2SkillScriptPath,
@@ -89,10 +92,10 @@ import {
   generateV2FlowYaml,
   generateV2ProjectYaml,
   generateV2AgentYaml,
+  parseV2FlowYaml,
   buildV2InlineSkill,
   buildV2FlowEvent,
   buildV2StateField,
-  parseV2FlowYaml,
   type V2InlineSkill,
   type V2FlowEvent,
   type V2StateField,
@@ -100,6 +103,7 @@ import {
 import { isContentDifferent } from '../../../sync/skill-files.js';
 import yaml from 'js-yaml';
 import { patchYamlToPyyaml } from '../../../format/yaml-patch.js';
+import type { RunnerType, SkillParameter } from '../../../types.js';
 
 /**
  * V2ProjectSyncStrategy - same API, newo_v2 file layout
@@ -655,9 +659,17 @@ export class V2ProjectSyncStrategy implements ISyncStrategy<ProjectMeta, LocalPr
     }
 
     const mapData = await fs.readJson(mapFile) as ProjectMap;
+    const metadataSync = await this.syncV2FlowYamlDefinitions(client, customer, mapData, newHashes);
+    result.created += metadataSync.created;
+    result.updated += metadataSync.updated;
+    result.errors.push(...metadataSync.errors);
 
     for (const change of changes) {
       try {
+        if (metadataSync.syncedPaths.has(change.path)) {
+          continue;
+        }
+
         if (change.operation === 'modified') {
           // V2 flow YAML: newo_customers/{cust}/{proj}/agents/{agent}/flows/{flow}/{flow}.yaml
           // The flow YAML carries title, events, and state_fields inline, so
@@ -682,6 +694,10 @@ export class V2ProjectSyncStrategy implements ISyncStrategy<ProjectMeta, LocalPr
       }
     }
 
+    if (metadataSync.created > 0 || metadataSync.updated > 0) {
+      await writeFileSafe(mapFile, JSON.stringify(mapData, null, 2));
+    }
+
     await saveHashes(newHashes, customer.idn);
 
     if (result.created > 0 || result.updated > 0) {
@@ -800,6 +816,321 @@ export class V2ProjectSyncStrategy implements ISyncStrategy<ProjectMeta, LocalPr
     return total;
   }
 
+  /**
+   * Reconcile inline skill definitions from V2 flow YAML before pushing scripts.
+   *
+   * V2 keeps skill metadata (model, runner_type, parameters) in the flow YAML,
+   * not in a separate skill metadata file. The map only contains the remote IDs
+   * from a previous pull, so new local skills must be created before their
+   * callers can be published.
+   */
+  private async syncV2FlowYamlDefinitions(
+    client: AxiosInstance,
+    customer: CustomerConfig,
+    mapData: ProjectMap,
+    newHashes: HashStore
+  ): Promise<{ created: number; updated: number; syncedPaths: Set<string>; errors: string[] }> {
+    let created = 0;
+    let updated = 0;
+    const syncedPaths = new Set<string>();
+    const errors: string[] = [];
+
+    for (const [projectIdn, projectData] of Object.entries(mapData.projects)) {
+      for (const [agentIdn, agentData] of Object.entries(projectData.agents)) {
+        for (const [flowIdn, flowData] of Object.entries(agentData.flows)) {
+          const flowYamlPath = v2FlowYamlPath(customer.idn, projectIdn, agentIdn, flowIdn);
+          if (!(await fs.pathExists(flowYamlPath))) {
+            continue;
+          }
+
+          let flowDef;
+          try {
+            flowDef = await parseV2FlowYaml(flowYamlPath);
+          } catch (error) {
+            this.logger.warn(
+              `[newo_v2] Failed to parse flow YAML ${flowYamlPath}: ${error instanceof Error ? error.message : String(error)}`
+            );
+            continue;
+          }
+
+          for (const skill of flowDef.skills || []) {
+            const skillLocator = `${projectIdn}/${agentIdn}/${flowIdn}/${skill.idn}`;
+            // Per-skill failure isolation: one broken skill must not abort the
+            // push of every other project/flow in the workspace.
+            try {
+              const runnerType = this.normalizeRunnerType(skill.runner_type);
+              const scriptPath = await this.resolveV2FlowSkillScriptPath(
+                customer.idn,
+                projectIdn,
+                agentIdn,
+                flowIdn,
+                skill.idn,
+                runnerType,
+                skill.prompt_script
+              );
+
+              if (!(await fs.pathExists(scriptPath))) {
+                errors.push(
+                  `[newo_v2] Missing script for skill ${skillLocator}: ${scriptPath}`
+                );
+                continue;
+              }
+
+              const content = await fs.readFile(scriptPath, 'utf8');
+              const localMetadata = this.buildV2SkillMetadataFromYaml(skill, flowDef, runnerType, flowData.skills[skill.idn]);
+              const existingSkill = flowData.skills[skill.idn];
+
+              if (!existingSkill) {
+                this.assertSkillModelResolved(localMetadata, skillLocator);
+                try {
+                  const createdSkill = await createSkill(client, flowData.id, {
+                    idn: localMetadata.idn,
+                    title: localMetadata.title,
+                    prompt_script: content,
+                    runner_type: localMetadata.runner_type,
+                    model: localMetadata.model,
+                    parameters: localMetadata.parameters,
+                    path: localMetadata.path || ''
+                  });
+
+                  // The create endpoint ignores inline `parameters` (verified
+                  // against the live platform) — create them explicitly.
+                  await this.createMissingSkillParameters(
+                    client,
+                    { ...localMetadata, id: createdSkill.id, parameters: [] },
+                    localMetadata
+                  );
+
+                  flowData.skills[skill.idn] = {
+                    ...localMetadata,
+                    id: createdSkill.id
+                  };
+                  newHashes[scriptPath] = sha256(content);
+                  syncedPaths.add(scriptPath);
+                  created++;
+                  this.logger.info(`[newo_v2] Created skill: ${flowIdn}/${skill.idn}`);
+                } catch (error) {
+                  if (!this.isAlreadyExistsApiError(error)) {
+                    throw error;
+                  }
+
+                  const remoteSkills = await listFlowSkills(client, flowData.id);
+                  const remoteSkill = remoteSkills.find(s => s.idn === skill.idn);
+                  if (!remoteSkill) {
+                    throw error;
+                  }
+
+                  const remoteMetadata: SkillMetadata = {
+                    id: remoteSkill.id,
+                    idn: remoteSkill.idn,
+                    title: remoteSkill.title,
+                    runner_type: remoteSkill.runner_type,
+                    model: remoteSkill.model,
+                    parameters: this.normalizeParameters(remoteSkill.parameters),
+                    path: remoteSkill.path
+                  };
+                  await this.createMissingSkillParameters(client, remoteMetadata, localMetadata);
+                  await updateSkill(client, {
+                    id: remoteSkill.id,
+                    title: localMetadata.title,
+                    idn: localMetadata.idn,
+                    prompt_script: content,
+                    runner_type: localMetadata.runner_type,
+                    model: localMetadata.model,
+                    parameters: localMetadata.parameters,
+                    path: remoteSkill.path || localMetadata.path
+                  });
+
+                  flowData.skills[skill.idn] = {
+                    ...localMetadata,
+                    id: remoteSkill.id,
+                    path: remoteSkill.path || localMetadata.path
+                  };
+                  newHashes[scriptPath] = sha256(content);
+                  syncedPaths.add(scriptPath);
+                  updated++;
+                  this.logger.info(`[newo_v2] Reused existing skill: ${flowIdn}/${skill.idn}`);
+                }
+                continue;
+              }
+
+              const createdParameters = await this.createMissingSkillParameters(client, existingSkill, localMetadata);
+
+              if (createdParameters > 0 || this.skillMetadataDiffers(existingSkill, localMetadata)) {
+                this.assertSkillModelResolved(localMetadata, skillLocator);
+                await updateSkill(client, {
+                  id: existingSkill.id,
+                  title: localMetadata.title,
+                  idn: localMetadata.idn,
+                  prompt_script: content,
+                  runner_type: localMetadata.runner_type,
+                  model: localMetadata.model,
+                  parameters: localMetadata.parameters,
+                  path: localMetadata.path
+                });
+
+                flowData.skills[skill.idn] = {
+                  ...localMetadata,
+                  id: existingSkill.id
+                };
+                newHashes[scriptPath] = sha256(content);
+                syncedPaths.add(scriptPath);
+                updated++;
+                this.logger.info(`[newo_v2] Updated skill metadata: ${flowIdn}/${skill.idn}`);
+              }
+            } catch (error) {
+              errors.push(
+                `Failed to sync skill ${skillLocator}: ${error instanceof Error ? error.message : String(error)}`
+              );
+            }
+          }
+        }
+      }
+    }
+
+    return { created, updated, syncedPaths, errors };
+  }
+
+  private async createMissingSkillParameters(
+    client: AxiosInstance,
+    existing: SkillMetadata,
+    local: SkillMetadata
+  ): Promise<number> {
+    const existingNames = new Set(this.normalizeParameters(existing.parameters).map(p => p.name));
+    let created = 0;
+
+    for (const parameter of local.parameters) {
+      if (existingNames.has(parameter.name)) {
+        continue;
+      }
+
+      try {
+        await createSkillParameter(client, existing.id, {
+          name: parameter.name,
+          default_value: parameter.default_value ?? ''
+        });
+        created++;
+        this.logger.info(`[newo_v2] Created skill parameter: ${local.idn}/${parameter.name}`);
+      } catch (error) {
+        if (!this.isAlreadyExistsApiError(error)) {
+          throw error;
+        }
+      }
+      existingNames.add(parameter.name);
+    }
+
+    return created;
+  }
+
+  /**
+   * Detect "resource already exists" API errors.
+   *
+   * Matches only on the precise phrases the platform actually returns
+   * ("already exists", "duplicate key"). Loose substrings like "exist"
+   * would otherwise sweep up unrelated "does not exist" / "doesn't exist"
+   * errors and trigger an incorrect reuse fallback.
+   */
+  private isAlreadyExistsApiError(error: unknown): boolean {
+    const response = (error as { response?: { status?: number; data?: unknown } } | null | undefined)?.response;
+    const status = response?.status;
+    if (status !== 400 && status !== 409 && status !== 422) {
+      return false;
+    }
+
+    const haystack = JSON.stringify(
+      response?.data ?? (error instanceof Error ? error.message : String(error))
+    ).toLowerCase();
+
+    return haystack.includes('already exists') || haystack.includes('duplicate key');
+  }
+
+  private normalizeRunnerType(runnerType: string | undefined): RunnerType {
+    return runnerType === 'nsl' ? 'nsl' : 'guidance';
+  }
+
+  private normalizeParameters(parameters: readonly SkillParameter[] | undefined): SkillParameter[] {
+    return (parameters || []).map(p => ({
+      name: p.name,
+      default_value: p.default_value ?? ''
+    }));
+  }
+
+  /**
+   * Fail fast if no model could be resolved for a V2 skill.
+   *
+   * `buildV2SkillMetadataFromYaml` falls back to empty strings when neither
+   * the skill nor the flow declare a model. The platform rejects empty
+   * model_idn/provider_idn at creation/update time, but the error it returns
+   * is generic — we surface a clearer message before issuing the request.
+   */
+  private assertSkillModelResolved(metadata: SkillMetadata, locator: string): void {
+    if (!metadata.model.model_idn || !metadata.model.provider_idn) {
+      throw new Error(
+        `[newo_v2] Cannot resolve model for skill ${locator}: ` +
+        `model_idn="${metadata.model.model_idn}", provider_idn="${metadata.model.provider_idn}". ` +
+        `Set either skill.model.* or flow default_model_idn/default_provider_idn in the flow YAML.`
+      );
+    }
+  }
+
+  private buildV2SkillMetadataFromYaml(
+    skill: V2InlineSkill,
+    flowDef: Awaited<ReturnType<typeof parseV2FlowYaml>>,
+    runnerType: RunnerType,
+    existing?: SkillMetadata
+  ): SkillMetadata {
+    return {
+      id: existing?.id || '',
+      idn: skill.idn,
+      title: skill.title || '',
+      runner_type: runnerType,
+      model: {
+        model_idn: skill.model?.model_idn || flowDef.default_model_idn || '',
+        provider_idn: skill.model?.provider_idn || flowDef.default_provider_idn || ''
+      },
+      parameters: this.normalizeParameters(skill.parameters),
+      path: existing?.path || ''
+    };
+  }
+
+  private skillMetadataDiffers(existing: SkillMetadata, local: SkillMetadata): boolean {
+    // Compare model/parameters field-by-field, never via JSON.stringify of the
+    // raw objects: the map stores model keys in platform API order
+    // (provider_idn first) while YAML-built metadata uses model_idn first, and
+    // a key-order-sensitive comparison flags every skill as changed.
+    const paramsKey = (params: readonly SkillParameter[] | undefined): string =>
+      JSON.stringify(
+        this.normalizeParameters(params).sort((a, b) => a.name.localeCompare(b.name))
+      );
+
+    return (
+      existing.title !== local.title ||
+      existing.runner_type !== local.runner_type ||
+      existing.model.model_idn !== local.model.model_idn ||
+      existing.model.provider_idn !== local.model.provider_idn ||
+      paramsKey(existing.parameters) !== paramsKey(local.parameters)
+    );
+  }
+
+  private async resolveV2FlowSkillScriptPath(
+    customerIdn: string,
+    projectIdn: string,
+    agentIdn: string,
+    flowIdn: string,
+    skillIdn: string,
+    runnerType: RunnerType,
+    promptScript?: string
+  ): Promise<string> {
+    if (promptScript) {
+      const fromPromptScript = `${v2AgentDir(customerIdn, projectIdn, agentIdn)}/${promptScript}`;
+      if (await fs.pathExists(fromPromptScript)) {
+        return fromPromptScript;
+      }
+    }
+
+    return v2SkillScriptPath(customerIdn, projectIdn, agentIdn, flowIdn, skillIdn, runnerType);
+  }
+
   /**
    * Push a V2 skill update
    *
@@ -949,11 +1280,30 @@ export class V2ProjectSyncStrategy implements ISyncStrategy<ProjectMeta, LocalPr
         }
 
         for (const [flowIdn, flowData] of Object.entries(agentData.flows)) {
-          for (const [skillIdn, skillMeta] of Object.entries(flowData.skills)) {
-            const scriptPath = v2SkillScriptPath(
-              customer.idn, projectIdn, agentIdn, flowIdn, skillIdn,
-              skillMeta.runner_type
-            );
+          const flowYamlSkills = await this.loadLocalV2FlowSkills(customer.idn, projectIdn, agentIdn, flowIdn);
+          const skillIdns = new Set([
+            ...Object.keys(flowData.skills),
+            ...flowYamlSkills.keys()
+          ]);
+
+          for (const skillIdn of skillIdns) {
+            const yamlSkill = flowYamlSkills.get(skillIdn);
+            const skillMeta = flowData.skills[skillIdn];
+            const runnerType = this.normalizeRunnerType(yamlSkill?.runner_type || skillMeta?.runner_type);
+            const scriptPath = yamlSkill
+              ? await this.resolveV2FlowSkillScriptPath(
+                customer.idn,
+                projectIdn,
+                agentIdn,
+                flowIdn,
+                skillIdn,
+                runnerType,
+                yamlSkill.prompt_script
+              )
+              : v2SkillScriptPath(
+                customer.idn, projectIdn, agentIdn, flowIdn, skillIdn,
+                runnerType
+              );
 
             if (await fs.pathExists(scriptPath)) {
               const content = await fs.readFile(scriptPath, 'utf8');
@@ -1002,6 +1352,25 @@ export class V2ProjectSyncStrategy implements ISyncStrategy<ProjectMeta, LocalPr
     return changes;
   }
 
+  private async loadLocalV2FlowSkills(
+    customerIdn: string,
+    projectIdn: string,
+    agentIdn: string,
+    flowIdn: string
+  ): Promise<Map<string, V2InlineSkill>> {
+    const flowYamlPath = v2FlowYamlPath(customerIdn, projectIdn, agentIdn, flowIdn);
+    if (!(await fs.pathExists(flowYamlPath))) {
+      return new Map();
+    }
+
+    try {
+      const flowDef = await parseV2FlowYaml(flowYamlPath);
+      return new Map((flowDef.skills || []).map(skill => [skill.idn, skill]));
+    } catch {
+      return new Map();
+    }
+  }
+
   async validate(customer: CustomerConfig, _items: LocalProjectData[]): Promise<ValidationResult> {
     const errors: ValidationError[] = [];
 
@@ -1020,7 +1389,61 @@ export class V2ProjectSyncStrategy implements ISyncStrategy<ProjectMeta, LocalPr
     for (const [projectIdn, projectData] of Object.entries(mapData.projects)) {
       for (const [agentIdn, agentData] of Object.entries(projectData.agents)) {
         for (const [flowIdn, flowData] of Object.entries(agentData.flows)) {
+          const flowYamlPath = v2FlowYamlPath(customer.idn, projectIdn, agentIdn, flowIdn);
+          let localYamlSkills: Map<string, V2InlineSkill> | undefined;
+          if (await fs.pathExists(flowYamlPath)) {
+            try {
+              const flowDef = await parseV2FlowYaml(flowYamlPath);
+              localYamlSkills = new Map((flowDef.skills || []).map(s => [s.idn, s]));
+              const skillIdns = new Set([
+                ...Object.keys(flowData.skills),
+                ...localYamlSkills.keys()
+              ]);
+
+              for (const skillIdn of skillIdns) {
+                const localYamlSkill = localYamlSkills.get(skillIdn);
+                const skillMeta = flowData.skills[skillIdn];
+
+                if (!localYamlSkill) {
+                  errors.push({
+                    field: `skill.${skillIdn}`,
+                    message: `Skill exists in project map but is missing from flow YAML: ${flowYamlPath}`,
+                    path: flowYamlPath
+                  });
+                  continue;
+                }
+
+                const runnerType = this.normalizeRunnerType(
+                  localYamlSkill.runner_type || skillMeta?.runner_type
+                );
+                const scriptPath = await this.resolveV2FlowSkillScriptPath(
+                  customer.idn,
+                  projectIdn,
+                  agentIdn,
+                  flowIdn,
+                  skillIdn,
+                  runnerType,
+                  localYamlSkill.prompt_script
+                );
+
+                if (!(await fs.pathExists(scriptPath))) {
+                  errors.push({
+                    field: `skill.${localYamlSkill.idn}`,
+                    message: `Script file not found: ${scriptPath}`,
+                    path: scriptPath
+                  });
+                }
+              }
+            } catch {
+              localYamlSkills = undefined;
+            }
+          }
+
           for (const [skillIdn, skillMeta] of Object.entries(flowData.skills)) {
+            if (localYamlSkills) {
+              continue;
+            }
+
             const scriptPath = v2SkillScriptPath(
               customer.idn, projectIdn, agentIdn, flowIdn, skillIdn,
               skillMeta.runner_type